/opt/canhelp/node_modules/zod/v4/core
Edit: /opt/canhelp/node_modules/zod/v4/core/schemas.d.cts (44698B)
import * as checks from "./checks.cjs";
import * as core from "./core.cjs";
import type * as errors from "./errors.cjs";
import type { StandardSchemaV1 } from "./standard-schema.cjs";
import * as util from "./util.cjs";
import { version } from "./versions.cjs";
export interface ParseContext
{
/** Customize error messages. */
readonly error?: errors.$ZodErrorMap;
/** Include the `input` field in issue objects. Default `false`. */
readonly reportInput?: boolean;
/** Skip eval-based fast path. Default `false`. */
readonly jitless?: boolean;
}
/** @internal */
export interface ParseContextInternal extends ParseContext {
readonly async?: boolean | undefined;
}
export interface ParsePayload {
value: T;
issues: errors.$ZodRawIssue[];
}
export type CheckFn = (input: ParsePayload) => util.MaybeAsync;
export interface $ZodTypeDef {
type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "custom";
error?: errors.$ZodErrorMap | undefined;
checks?: checks.$ZodCheck[];
}
export interface _$ZodTypeInternals {
/** The `@zod/core` version of this schema */
version: typeof version;
/** Schema definition. */
def: $ZodTypeDef;
/** @internal Randomly generated ID for this schema. */
/** @internal List of deferred initializers. */
deferred: util.AnyFunc[] | undefined;
/** @internal Parses input and runs all checks (refinements). */
run(payload: ParsePayload, ctx: ParseContextInternal): util.MaybeAsync;
/** @internal Parses input, doesn't run checks. */
parse(payload: ParsePayload, ctx: ParseContextInternal): util.MaybeAsync;
/** @internal Stores identifiers for the set of traits implemented by this schema. */
traits: Set;
/** @internal Indicates that a schema output type should be considered optional inside objects.
* @default Required
*/
/** @internal */
optin?: "optional" | undefined;
/** @internal */
optout?: "optional" | undefined;
/** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
*
* Defined on: enum, const, literal, null, undefined
* Passthrough: optional, nullable, branded, default, catch, pipe
* Todo: unions?
*/
values?: util.PrimitiveSet | undefined;
/** @internal A set of literal discriminators used for the fast path in discriminated unions. */
propValues?: util.PropValues | undefined;
/** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
pattern: RegExp | undefined;
/** @internal The constructor function of this schema. */
constr: new (def: any) => $ZodType;
/** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
bag: Record;
/** @internal The set of issues this schema might throw during type checking. */
isst: errors.$ZodIssueBase;
/** An optional method used to override `toJSONSchema` logic. */
toJSONSchema?: () => unknown;
/** @internal The parent of this schema. Only set during certain clone operations. */
parent?: $ZodType | undefined;
}
/** @internal */
export interface $ZodTypeInternals extends _$ZodTypeInternals {
/** @internal The inferred output type */
output: O;
/** @internal The inferred input type */
input: I;
}
export type $ZodStandardSchema = StandardSchemaV1.Props, core.output>;
export type SomeType = {
_zod: _$ZodTypeInternals;
};
export interface $ZodType = $ZodTypeInternals> {
_zod: Internals;
"~standard": $ZodStandardSchema;
}
export interface _$ZodType extends $ZodType {
}
export declare const $ZodType: core.$constructor<$ZodType>;
export { clone } from "./util.cjs";
export interface $ZodStringDef extends $ZodTypeDef {
type: "string";
coerce?: boolean;
checks?: checks.$ZodCheck[];
}
export interface $ZodStringInternals extends $ZodTypeInternals {
def: $ZodStringDef;
/** @deprecated Internal API, use with caution (not deprecated) */
pattern: RegExp;
/** @deprecated Internal API, use with caution (not deprecated) */
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: number;
maximum: number;
patterns: Set;
format: string;
contentEncoding: string;
}>;
}
export interface $ZodString extends _$ZodType<$ZodStringInternals> {
}
export declare const $ZodString: core.$constructor<$ZodString>;
export interface $ZodStringFormatDef extends $ZodStringDef, checks.$ZodCheckStringFormatDef {
}
export interface $ZodStringFormatInternals extends $ZodStringInternals, checks.$ZodCheckStringFormatInternals {
def: $ZodStringFormatDef;
}
export interface $ZodStringFormat extends $ZodType {
_zod: $ZodStringFormatInternals;
}
export declare const $ZodStringFormat: core.$constructor<$ZodStringFormat>;
export interface $ZodGUIDDef extends $ZodStringFormatDef<"guid"> {
}
export interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {
}
export interface $ZodGUID extends $ZodType {
_zod: $ZodGUIDInternals;
}
export declare const $ZodGUID: core.$constructor<$ZodGUID>;
export interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
}
export interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
def: $ZodUUIDDef;
}
export interface $ZodUUID extends $ZodType {
_zod: $ZodUUIDInternals;
}
export declare const $ZodUUID: core.$constructor<$ZodUUID>;
export interface $ZodEmailDef extends $ZodStringFormatDef<"email"> {
}
export interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {
}
export interface $ZodEmail extends $ZodType {
_zod: $ZodEmailInternals;
}
export declare const $ZodEmail: core.$constructor<$ZodEmail>;
export interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
hostname?: RegExp | undefined;
protocol?: RegExp | undefined;
}
export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
def: $ZodURLDef;
}
export interface $ZodURL extends $ZodType {
_zod: $ZodURLInternals;
}
export declare const $ZodURL: core.$constructor<$ZodURL>;
export interface $ZodEmojiDef extends $ZodStringFormatDef<"emoji"> {
}
export interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {
}
export interface $ZodEmoji extends $ZodType {
_zod: $ZodEmojiInternals;
}
export declare const $ZodEmoji: core.$constructor<$ZodEmoji>;
export interface $ZodNanoIDDef extends $ZodStringFormatDef<"nanoid"> {
}
export interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {
}
export interface $ZodNanoID extends $ZodType {
_zod: $ZodNanoIDInternals;
}
export declare const $ZodNanoID: core.$constructor<$ZodNanoID>;
export interface $ZodCUIDDef extends $ZodStringFormatDef<"cuid"> {
}
export interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {
}
export interface $ZodCUID extends $ZodType {
_zod: $ZodCUIDInternals;
}
export declare const $ZodCUID: core.$constructor<$ZodCUID>;
export interface $ZodCUID2Def extends $ZodStringFormatDef<"cuid2"> {
}
export interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {
}
export interface $ZodCUID2 extends $ZodType {
_zod: $ZodCUID2Internals;
}
export declare const $ZodCUID2: core.$constructor<$ZodCUID2>;
export interface $ZodULIDDef extends $ZodStringFormatDef<"ulid"> {
}
export interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {
}
export interface $ZodULID extends $ZodType {
_zod: $ZodULIDInternals;
}
export declare const $ZodULID: core.$constructor<$ZodULID>;
export interface $ZodXIDDef extends $ZodStringFormatDef<"xid"> {
}
export interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {
}
export interface $ZodXID extends $ZodType {
_zod: $ZodXIDInternals;
}
export declare const $ZodXID: core.$constructor<$ZodXID>;
export interface $ZodKSUIDDef extends $ZodStringFormatDef<"ksuid"> {
}
export interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {
}
export interface $ZodKSUID extends $ZodType {
_zod: $ZodKSUIDInternals;
}
export declare const $ZodKSUID: core.$constructor<$ZodKSUID>;
export interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
precision: number | null;
offset: boolean;
local: boolean;
}
export interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
def: $ZodISODateTimeDef;
}
export interface $ZodISODateTime extends $ZodType {
_zod: $ZodISODateTimeInternals;
}
export declare const $ZodISODateTime: core.$constructor<$ZodISODateTime>;
export interface $ZodISODateDef extends $ZodStringFormatDef<"date"> {
}
export interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {
}
export interface $ZodISODate extends $ZodType {
_zod: $ZodISODateInternals;
}
export declare const $ZodISODate: core.$constructor<$ZodISODate>;
export interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
precision?: number | null;
}
export interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
def: $ZodISOTimeDef;
}
export interface $ZodISOTime extends $ZodType {
_zod: $ZodISOTimeInternals;
}
export declare const $ZodISOTime: core.$constructor<$ZodISOTime>;
export interface $ZodISODurationDef extends $ZodStringFormatDef<"duration"> {
}
export interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {
}
export interface $ZodISODuration extends $ZodType {
_zod: $ZodISODurationInternals;
}
export declare const $ZodISODuration: core.$constructor<$ZodISODuration>;
export interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
version?: "v4";
}
export interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
def: $ZodIPv4Def;
}
export interface $ZodIPv4 extends $ZodType {
_zod: $ZodIPv4Internals;
}
export declare const $ZodIPv4: core.$constructor<$ZodIPv4>;
export interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
version?: "v6";
}
export interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
def: $ZodIPv6Def;
}
export interface $ZodIPv6 extends $ZodType {
_zod: $ZodIPv6Internals;
}
export declare const $ZodIPv6: core.$constructor<$ZodIPv6>;
export interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
version?: "v4";
}
export interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
def: $ZodCIDRv4Def;
}
export interface $ZodCIDRv4 extends $ZodType {
_zod: $ZodCIDRv4Internals;
}
export declare const $ZodCIDRv4: core.$constructor<$ZodCIDRv4>;
export interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
version?: "v6";
}
export interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
def: $ZodCIDRv6Def;
}
export interface $ZodCIDRv6 extends $ZodType {
_zod: $ZodCIDRv6Internals;
}
export declare const $ZodCIDRv6: core.$constructor<$ZodCIDRv6>;
export declare function isValidBase64(data: string): boolean;
export interface $ZodBase64Def extends $ZodStringFormatDef<"base64"> {
}
export interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {
}
export interface $ZodBase64 extends $ZodType {
_zod: $ZodBase64Internals;
}
export declare const $ZodBase64: core.$constructor<$ZodBase64>;
export declare function isValidBase64URL(data: string): boolean;
export interface $ZodBase64URLDef extends $ZodStringFormatDef<"base64url"> {
}
export interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {
}
export interface $ZodBase64URL extends $ZodType {
_zod: $ZodBase64URLInternals;
}
export declare const $ZodBase64URL: core.$constructor<$ZodBase64URL>;
export interface $ZodE164Def extends $ZodStringFormatDef<"e164"> {
}
export interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {
}
export interface $ZodE164 extends $ZodType {
_zod: $ZodE164Internals;
}
export declare const $ZodE164: core.$constructor<$ZodE164>;
export declare function isValidJWT(token: string, algorithm?: util.JWTAlgorithm | null): boolean;
export interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
alg?: util.JWTAlgorithm | undefined;
}
export interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
def: $ZodJWTDef;
}
export interface $ZodJWT extends $ZodType {
_zod: $ZodJWTInternals;
}
export declare const $ZodJWT: core.$constructor<$ZodJWT>;
export interface $ZodCustomStringFormatDef extends $ZodStringFormatDef {
fn: (val: string) => unknown;
}
export interface $ZodCustomStringFormatInternals extends $ZodStringFormatInternals {
def: $ZodCustomStringFormatDef;
}
export interface $ZodCustomStringFormat extends $ZodStringFormat {
_zod: $ZodCustomStringFormatInternals;
}
export declare const $ZodCustomStringFormat: core.$constructor<$ZodCustomStringFormat>;
export interface $ZodNumberDef extends $ZodTypeDef {
type: "number";
coerce?: boolean;
}
export interface $ZodNumberInternals extends $ZodTypeInternals {
def: $ZodNumberDef;
/** @deprecated Internal API, use with caution (not deprecated) */
pattern: RegExp;
/** @deprecated Internal API, use with caution (not deprecated) */
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: number;
maximum: number;
exclusiveMinimum: number;
exclusiveMaximum: number;
format: string;
pattern: RegExp;
}>;
}
export interface $ZodNumber extends $ZodType {
_zod: $ZodNumberInternals;
}
export declare const $ZodNumber: core.$constructor<$ZodNumber>;
export interface $ZodNumberFormatDef extends $ZodNumberDef, checks.$ZodCheckNumberFormatDef {
}
export interface $ZodNumberFormatInternals extends $ZodNumberInternals, checks.$ZodCheckNumberFormatInternals {
def: $ZodNumberFormatDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNumberFormat extends $ZodType {
_zod: $ZodNumberFormatInternals;
}
export declare const $ZodNumberFormat: core.$constructor<$ZodNumberFormat>;
export interface $ZodBooleanDef extends $ZodTypeDef {
type: "boolean";
coerce?: boolean;
checks?: checks.$ZodCheck[];
}
export interface $ZodBooleanInternals extends $ZodTypeInternals {
pattern: RegExp;
def: $ZodBooleanDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodBoolean extends $ZodType {
_zod: $ZodBooleanInternals;
}
export declare const $ZodBoolean: core.$constructor<$ZodBoolean>;
export interface $ZodBigIntDef extends $ZodTypeDef {
type: "bigint";
coerce?: boolean;
}
export interface $ZodBigIntInternals extends $ZodTypeInternals {
pattern: RegExp;
/** @internal Internal API, use with caution */
def: $ZodBigIntDef;
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: bigint;
maximum: bigint;
format: string;
}>;
}
export interface $ZodBigInt extends $ZodType {
_zod: $ZodBigIntInternals;
}
export declare const $ZodBigInt: core.$constructor<$ZodBigInt>;
export interface $ZodBigIntFormatDef extends $ZodBigIntDef, checks.$ZodCheckBigIntFormatDef {
check: "bigint_format";
}
export interface $ZodBigIntFormatInternals extends $ZodBigIntInternals, checks.$ZodCheckBigIntFormatInternals {
def: $ZodBigIntFormatDef;
}
export interface $ZodBigIntFormat extends $ZodType {
_zod: $ZodBigIntFormatInternals;
}
export declare const $ZodBigIntFormat: core.$constructor<$ZodBigIntFormat>;
export interface $ZodSymbolDef extends $ZodTypeDef {
type: "symbol";
}
export interface $ZodSymbolInternals extends $ZodTypeInternals {
def: $ZodSymbolDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodSymbol extends $ZodType {
_zod: $ZodSymbolInternals;
}
export declare const $ZodSymbol: core.$constructor<$ZodSymbol>;
export interface $ZodUndefinedDef extends $ZodTypeDef {
type: "undefined";
}
export interface $ZodUndefinedInternals extends $ZodTypeInternals {
pattern: RegExp;
def: $ZodUndefinedDef;
values: util.PrimitiveSet;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodUndefined extends $ZodType {
_zod: $ZodUndefinedInternals;
}
export declare const $ZodUndefined: core.$constructor<$ZodUndefined>;
export interface $ZodNullDef extends $ZodTypeDef {
type: "null";
}
export interface $ZodNullInternals extends $ZodTypeInternals {
pattern: RegExp;
def: $ZodNullDef;
values: util.PrimitiveSet;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNull extends $ZodType {
_zod: $ZodNullInternals;
}
export declare const $ZodNull: core.$constructor<$ZodNull>;
export interface $ZodAnyDef extends $ZodTypeDef {
type: "any";
}
export interface $ZodAnyInternals extends $ZodTypeInternals {
def: $ZodAnyDef;
isst: never;
}
export interface $ZodAny extends $ZodType {
_zod: $ZodAnyInternals;
}
export declare const $ZodAny: core.$constructor<$ZodAny>;
export interface $ZodUnknownDef extends $ZodTypeDef {
type: "unknown";
}
export interface $ZodUnknownInternals extends $ZodTypeInternals {
def: $ZodUnknownDef;
isst: never;
}
export interface $ZodUnknown extends $ZodType {
_zod: $ZodUnknownInternals;
}
export declare const $ZodUnknown: core.$constructor<$ZodUnknown>;
export interface $ZodNeverDef extends $ZodTypeDef {
type: "never";
}
export interface $ZodNeverInternals extends $ZodTypeInternals {
def: $ZodNeverDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNever extends $ZodType {
_zod: $ZodNeverInternals;
}
export declare const $ZodNever: core.$constructor<$ZodNever>;
export interface $ZodVoidDef extends $ZodTypeDef {
type: "void";
}
export interface $ZodVoidInternals extends $ZodTypeInternals {
def: $ZodVoidDef;
isst: errors.$ZodIssueInvalidType;
}
export interface $ZodVoid extends $ZodType {
_zod: $ZodVoidInternals;
}
export declare const $ZodVoid: core.$constructor<$ZodVoid>;
export interface $ZodDateDef extends $ZodTypeDef {
type: "date";
coerce?: boolean;
}
export interface $ZodDateInternals extends $ZodTypeInternals {
def: $ZodDateDef;
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: Date;
maximum: Date;
format: string;
}>;
}
export interface $ZodDate extends $ZodType {
_zod: $ZodDateInternals;
}
export declare const $ZodDate: core.$constructor<$ZodDate>;
export interface $ZodArrayDef extends $ZodTypeDef {
type: "array";
element: T;
}
export interface $ZodArrayInternals extends _$ZodTypeInternals {
def: $ZodArrayDef;
isst: errors.$ZodIssueInvalidType;
output: core.output[];
input: core.input[];
}
export interface $ZodArray extends $ZodType> {
}
export declare const $ZodArray: core.$constructor<$ZodArray>;
type OptionalOutSchema = {
_zod: {
optout: "optional";
};
};
type OptionalInSchema = {
_zod: {
optin: "optional";
};
};
export type $InferObjectOutput> = string extends keyof T ? util.IsAny extends true ? Record : Record> : keyof (T & Extra) extends never ? Record : util.Prettify<{
-readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
} & {
-readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
} & Extra>;
export type $InferObjectInput> = string extends keyof T ? util.IsAny extends true ? Record : Record> : keyof (T & Extra) extends never ? Record : util.Prettify<{
-readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
} & {
-readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
} & Extra>;
export type $ZodObjectConfig = {
out: Record;
in: Record;
};
export type $loose = {
out: Record;
in: Record;
};
export type $strict = {
out: {};
in: {};
};
export type $strip = {
out: {};
in: {};
};
export type $catchall = {
out: {
[k: string]: core.output;
};
in: {
[k: string]: core.input;
};
};
export type $ZodShape = Readonly<{
[k: string]: $ZodType;
}>;
export interface $ZodObjectDef extends $ZodTypeDef {
type: "object";
shape: Shape;
catchall?: $ZodType | undefined;
}
export interface $ZodObjectInternals<
/** @ts-ignore Cast variance */
out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
def: $ZodObjectDef;
config: Config;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
propValues: util.PropValues;
output: $InferObjectOutput;
input: $InferObjectInput;
}
export type $ZodLooseShape = Record;
export interface $ZodObject<
/** @ts-ignore Cast variance */
out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType> {
"~standard": $ZodStandardSchema;
}
export declare const $ZodObject: core.$constructor<$ZodObject>;
export type $InferUnionOutput = T extends any ? core.output : never;
export type $InferUnionInput = T extends any ? core.input : never;
export interface $ZodUnionDef extends $ZodTypeDef {
type: "union";
options: Options;
}
type IsOptionalIn = T extends OptionalInSchema ? true : false;
type IsOptionalOut = T extends OptionalOutSchema ? true : false;
export interface $ZodUnionInternals extends _$ZodTypeInternals {
def: $ZodUnionDef;
isst: errors.$ZodIssueInvalidUnion;
pattern: T[number]["_zod"]["pattern"];
values: T[number]["_zod"]["values"];
output: $InferUnionOutput;
input: $InferUnionInput;
optin: IsOptionalIn extends false ? "optional" | undefined : "optional";
optout: IsOptionalOut extends false ? "optional" | undefined : "optional";
}
export interface $ZodUnion extends $ZodType> {
_zod: $ZodUnionInternals;
}
export declare const $ZodUnion: core.$constructor<$ZodUnion>;
export interface $ZodDiscriminatedUnionDef extends $ZodUnionDef {
discriminator: string;
unionFallback?: boolean;
}
export interface $ZodDiscriminatedUnionInternals extends $ZodUnionInternals {
def: $ZodDiscriminatedUnionDef;
propValues: util.PropValues;
}
export interface $ZodDiscriminatedUnion extends $ZodType {
_zod: $ZodDiscriminatedUnionInternals;
}
export declare const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion>;
export interface $ZodIntersectionDef extends $ZodTypeDef {
type: "intersection";
left: Left;
right: Right;
}
export interface $ZodIntersectionInternals extends $ZodTypeInternals & core.output, core.input & core.input> {
def: $ZodIntersectionDef;
isst: never;
optin: A["_zod"]["optin"] | B["_zod"]["optin"];
optout: A["_zod"]["optout"] | B["_zod"]["optout"];
}
export interface $ZodIntersection extends $ZodType {
_zod: $ZodIntersectionInternals;
}
export declare const $ZodIntersection: core.$constructor<$ZodIntersection>;
export interface $ZodTupleDef extends $ZodTypeDef {
type: "tuple";
items: T;
rest: Rest;
}
export type $InferTupleInputType = [
...TupleInputTypeWithOptionals,
...(Rest extends SomeType ? core.input[] : [])
];
type TupleInputTypeNoOptionals = {
[k in keyof T]: core.input;
};
type TupleInputTypeWithOptionals = T extends readonly [
...infer Prefix extends SomeType[],
infer Tail extends SomeType
] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals, core.input?] : TupleInputTypeNoOptionals : [];
export type $InferTupleOutputType = [
...TupleOutputTypeWithOptionals,
...(Rest extends SomeType ? core.output[] : [])
];
type TupleOutputTypeNoOptionals = {
[k in keyof T]: core.output;
};
type TupleOutputTypeWithOptionals = T extends readonly [
...infer Prefix extends SomeType[],
infer Tail extends SomeType
] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals, core.output?] : TupleOutputTypeNoOptionals : [];
export interface $ZodTupleInternals extends $ZodTypeInternals<$InferTupleOutputType, $InferTupleInputType> {
def: $ZodTupleDef;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig | errors.$ZodIssueTooSmall;
}
export interface $ZodTuple extends $ZodType {
_zod: $ZodTupleInternals;
}
export declare const $ZodTuple: core.$constructor<$ZodTuple>;
export type $ZodRecordKey = $ZodType;
export interface $ZodRecordDef extends $ZodTypeDef {
type: "record";
keyType: Key;
valueType: Value;
}
export type $InferZodRecordOutput = Key extends $partial ? Partial, core.output>> : Record, core.output>;
export type $InferZodRecordInput = Key extends $partial ? Partial, core.input>> : Record, core.input>;
export interface $ZodRecordInternals extends $ZodTypeInternals<$InferZodRecordOutput, $InferZodRecordInput> {
def: $ZodRecordDef;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey>;
optin?: "optional" | undefined;
optout?: "optional" | undefined;
}
export type $partial = {
"~~partial": true;
};
export interface $ZodRecord extends $ZodType {
_zod: $ZodRecordInternals;
}
export declare const $ZodRecord: core.$constructor<$ZodRecord>;
export interface $ZodMapDef extends $ZodTypeDef {
type: "map";
keyType: Key;
valueType: Value;
}
export interface $ZodMapInternals extends $ZodTypeInternals, core.output>, Map, core.input>> {
def: $ZodMapDef;
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey | errors.$ZodIssueInvalidElement;
optin?: "optional" | undefined;
optout?: "optional" | undefined;
}
export interface $ZodMap extends $ZodType {
_zod: $ZodMapInternals;
}
export declare const $ZodMap: core.$constructor<$ZodMap>;
export interface $ZodSetDef extends $ZodTypeDef {
type: "set";
valueType: T;
}
export interface $ZodSetInternals extends $ZodTypeInternals>, Set>> {
def: $ZodSetDef;
isst: errors.$ZodIssueInvalidType;
optin?: "optional" | undefined;
optout?: "optional" | undefined;
}
export interface $ZodSet extends $ZodType {
_zod: $ZodSetInternals;
}
export declare const $ZodSet: core.$constructor<$ZodSet>;
export type $InferEnumOutput = T[keyof T] & {};
export type $InferEnumInput = T[keyof T] & {};
export interface $ZodEnumDef extends $ZodTypeDef {
type: "enum";
entries: T;
}
export interface $ZodEnumInternals<
/** @ts-ignore Cast variance */
out T extends util.EnumLike = util.EnumLike> extends $ZodTypeInternals<$InferEnumOutput, $InferEnumInput> {
def: $ZodEnumDef;
/** @deprecated Internal API, use with caution (not deprecated) */
values: util.PrimitiveSet;
/** @deprecated Internal API, use with caution (not deprecated) */
pattern: RegExp;
isst: errors.$ZodIssueInvalidValue;
}
export interface $ZodEnum extends $ZodType {
_zod: $ZodEnumInternals;
}
export declare const $ZodEnum: core.$constructor<$ZodEnum>;
export interface $ZodLiteralDef extends $ZodTypeDef {
type: "literal";
values: T[];
}
export interface $ZodLiteralInternals extends $ZodTypeInternals {
def: $ZodLiteralDef;
values: Set;
pattern: RegExp;
isst: errors.$ZodIssueInvalidValue;
}
export interface $ZodLiteral extends $ZodType {
_zod: $ZodLiteralInternals;
}
export declare const $ZodLiteral: core.$constructor<$ZodLiteral>;
declare global {
interface File {
}
}
export interface $ZodFileDef extends $ZodTypeDef {
type: "file";
}
export interface $ZodFileInternals extends $ZodTypeInternals {
def: $ZodFileDef;
isst: errors.$ZodIssueInvalidType;
bag: util.LoosePartial<{
minimum: number;
maximum: number;
mime: util.MimeTypes[];
}>;
}
export interface $ZodFile extends $ZodType {
_zod: $ZodFileInternals;
}
export declare const $ZodFile: core.$constructor<$ZodFile>;
export interface $ZodTransformDef extends $ZodTypeDef {
type: "transform";
transform: (input: unknown, payload: ParsePayload) => util.MaybeAsync;
}
export interface $ZodTransformInternals extends $ZodTypeInternals {
def: $ZodTransformDef;
isst: never;
}
export interface $ZodTransform extends $ZodType {
_zod: $ZodTransformInternals;
}
export declare const $ZodTransform: core.$constructor<$ZodTransform>;
export interface $ZodOptionalDef extends $ZodTypeDef {
type: "optional";
innerType: T;
}
export interface $ZodOptionalInternals extends $ZodTypeInternals | undefined, core.input | undefined> {
def: $ZodOptionalDef;
optin: "optional";
optout: "optional";
isst: never;
values: T["_zod"]["values"];
pattern: T["_zod"]["pattern"];
}
export interface $ZodOptional extends $ZodType {
_zod: $ZodOptionalInternals;
}
export declare const $ZodOptional: core.$constructor<$ZodOptional>;
export interface $ZodNullableDef extends $ZodTypeDef {
type: "nullable";
innerType: T;
}
export interface $ZodNullableInternals extends $ZodTypeInternals | null, core.input | null> {
def: $ZodNullableDef;
optin: T["_zod"]["optin"];
optout: T["_zod"]["optout"];
isst: never;
values: T["_zod"]["values"];
pattern: T["_zod"]["pattern"];
}
export interface $ZodNullable extends $ZodType {
_zod: $ZodNullableInternals;
}
export declare const $ZodNullable: core.$constructor<$ZodNullable>;
export interface $ZodDefaultDef extends $ZodTypeDef {
type: "default";
innerType: T;
/** The default value. May be a getter. */
defaultValue: util.NoUndefined>;
}
export interface $ZodDefaultInternals extends $ZodTypeInternals>, core.input | undefined> {
def: $ZodDefaultDef;
optin: "optional";
optout?: "optional" | undefined;
isst: never;
values: T["_zod"]["values"];
}
export interface $ZodDefault extends $ZodType {
_zod: $ZodDefaultInternals;
}
export declare const $ZodDefault: core.$constructor<$ZodDefault>;
export interface $ZodPrefaultDef extends $ZodTypeDef {
type: "prefault";
innerType: T;
/** The default value. May be a getter. */
defaultValue: core.input;
}
export interface $ZodPrefaultInternals extends $ZodTypeInternals>, core.input | undefined> {
def: $ZodPrefaultDef;
optin: "optional";
optout?: "optional" | undefined;
isst: never;
values: T["_zod"]["values"];
}
export interface $ZodPrefault extends $ZodType {
_zod: $ZodPrefaultInternals;
}
export declare const $ZodPrefault: core.$constructor<$ZodPrefault>;
export interface $ZodNonOptionalDef extends $ZodTypeDef {
type: "nonoptional";
innerType: T;
}
export interface $ZodNonOptionalInternals extends $ZodTypeInternals>, util.NoUndefined>> {
def: $ZodNonOptionalDef;
isst: errors.$ZodIssueInvalidType;
values: T["_zod"]["values"];
optin: "optional" | undefined;
optout: "optional" | undefined;
}
export interface $ZodNonOptional extends $ZodType {
_zod: $ZodNonOptionalInternals;
}
export declare const $ZodNonOptional: core.$constructor<$ZodNonOptional>;
export interface $ZodSuccessDef extends $ZodTypeDef {
type: "success";
innerType: T;
}
export interface $ZodSuccessInternals