/opt/canhelp/node_modules/zod/v4/classic
Edit: /opt/canhelp/node_modules/zod/v4/classic/schemas.d.cts (38862B)
import * as core from "../core/index.cjs";
import { util } from "../core/index.cjs";
import * as parse from "./parse.cjs";
export interface RefinementCtx
extends core.ParsePayload {
addIssue(arg: string | core.$ZodRawIssue | Partial): void;
}
export interface ZodType = core.$ZodTypeInternals> extends core.$ZodType {
def: Internals["def"];
type: Internals["def"]["type"];
/** @deprecated Use `.def` instead. */
_def: Internals["def"];
/** @deprecated Use `z.output` instead. */
_output: Internals["output"];
/** @deprecated Use `z.input` instead. */
_input: Internals["input"];
check(...checks: (core.CheckFn> | core.$ZodCheck>)[]): this;
clone(def?: Internals["def"], params?: {
parent: boolean;
}): this;
register(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$replace?] : [core.$replace] : ["Incompatible schema"]): this;
brand(value?: T): PropertyKey extends T ? this : core.$ZodBranded;
parse(data: unknown, params?: core.ParseContext): core.output;
safeParse(data: unknown, params?: core.ParseContext): parse.ZodSafeParseResult>;
parseAsync(data: unknown, params?: core.ParseContext): Promise>;
safeParseAsync(data: unknown, params?: core.ParseContext): Promise>>;
spa: (data: unknown, params?: core.ParseContext) => Promise>>;
refine(check: (arg: core.output) => unknown | Promise, params?: string | core.$ZodCustomParams): this;
/** @deprecated Use `.check()` instead. */
superRefine(refinement: (arg: core.output, ctx: RefinementCtx>) => void | Promise): this;
overwrite(fn: (x: core.output) => core.output): this;
optional(): ZodOptional;
nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional;
nullable(): ZodNullable;
nullish(): ZodOptional>;
default(def: core.output): ZodDefault;
default(def: () => util.NoUndefined>): ZodDefault;
prefault(def: () => core.input): ZodPrefault;
prefault(def: core.input): ZodPrefault;
array(): ZodArray;
or(option: T): ZodUnion<[this, T]>;
and(incoming: T): ZodIntersection;
transform(transform: (arg: core.output, ctx: RefinementCtx>) => NewOut | Promise): ZodPipe, core.output>>;
catch(def: core.output): ZodCatch;
catch(def: (ctx: core.$ZodCatchCtx) => core.output): ZodCatch;
pipe>>(target: T | core.$ZodType>): ZodPipe;
readonly(): ZodReadonly;
/** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
describe(description: string): this;
description?: string;
/** Returns the metadata associated with this instance in `z.globalRegistry` */
meta(): core.$replace | undefined;
/** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
meta(data: core.$replace): this;
/** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
*
* ```ts
* const schema = z.string().optional();
* const isOptional = schema.safeParse(undefined).success; // true
* ```
*/
isOptional(): boolean;
/**
* @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
*
* ```ts
* const schema = z.string().nullable();
* const isNullable = schema.safeParse(null).success; // true
* ```
*/
isNullable(): boolean;
}
export interface _ZodType extends ZodType {
}
export declare const ZodType: core.$constructor;
export interface _ZodString = core.$ZodStringInternals> extends _ZodType {
format: string | null;
minLength: number | null;
maxLength: number | null;
regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;
includes(value: string, params?: core.$ZodCheckIncludesParams): this;
startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this;
endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this;
min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
lowercase(params?: string | core.$ZodCheckLowerCaseParams): this;
uppercase(params?: string | core.$ZodCheckUpperCaseParams): this;
trim(): this;
normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
toLowerCase(): this;
toUpperCase(): this;
}
/** @internal */
export declare const _ZodString: core.$constructor<_ZodString>;
export interface ZodString extends _ZodString> {
/** @deprecated Use `z.email()` instead. */
email(params?: string | core.$ZodCheckEmailParams): this;
/** @deprecated Use `z.url()` instead. */
url(params?: string | core.$ZodCheckURLParams): this;
/** @deprecated Use `z.jwt()` instead. */
jwt(params?: string | core.$ZodCheckJWTParams): this;
/** @deprecated Use `z.emoji()` instead. */
emoji(params?: string | core.$ZodCheckEmojiParams): this;
/** @deprecated Use `z.guid()` instead. */
guid(params?: string | core.$ZodCheckGUIDParams): this;
/** @deprecated Use `z.uuid()` instead. */
uuid(params?: string | core.$ZodCheckUUIDParams): this;
/** @deprecated Use `z.uuid()` instead. */
uuidv4(params?: string | core.$ZodCheckUUIDParams): this;
/** @deprecated Use `z.uuid()` instead. */
uuidv6(params?: string | core.$ZodCheckUUIDParams): this;
/** @deprecated Use `z.uuid()` instead. */
uuidv7(params?: string | core.$ZodCheckUUIDParams): this;
/** @deprecated Use `z.nanoid()` instead. */
nanoid(params?: string | core.$ZodCheckNanoIDParams): this;
/** @deprecated Use `z.guid()` instead. */
guid(params?: string | core.$ZodCheckGUIDParams): this;
/** @deprecated Use `z.cuid()` instead. */
cuid(params?: string | core.$ZodCheckCUIDParams): this;
/** @deprecated Use `z.cuid2()` instead. */
cuid2(params?: string | core.$ZodCheckCUID2Params): this;
/** @deprecated Use `z.ulid()` instead. */
ulid(params?: string | core.$ZodCheckULIDParams): this;
/** @deprecated Use `z.base64()` instead. */
base64(params?: string | core.$ZodCheckBase64Params): this;
/** @deprecated Use `z.base64url()` instead. */
base64url(params?: string | core.$ZodCheckBase64URLParams): this;
/** @deprecated Use `z.xid()` instead. */
xid(params?: string | core.$ZodCheckXIDParams): this;
/** @deprecated Use `z.ksuid()` instead. */
ksuid(params?: string | core.$ZodCheckKSUIDParams): this;
/** @deprecated Use `z.ipv4()` instead. */
ipv4(params?: string | core.$ZodCheckIPv4Params): this;
/** @deprecated Use `z.ipv6()` instead. */
ipv6(params?: string | core.$ZodCheckIPv6Params): this;
/** @deprecated Use `z.cidrv4()` instead. */
cidrv4(params?: string | core.$ZodCheckCIDRv4Params): this;
/** @deprecated Use `z.cidrv6()` instead. */
cidrv6(params?: string | core.$ZodCheckCIDRv6Params): this;
/** @deprecated Use `z.e164()` instead. */
e164(params?: string | core.$ZodCheckE164Params): this;
/** @deprecated Use `z.iso.datetime()` instead. */
datetime(params?: string | core.$ZodCheckISODateTimeParams): this;
/** @deprecated Use `z.iso.date()` instead. */
date(params?: string | core.$ZodCheckISODateParams): this;
/** @deprecated Use `z.iso.time()` instead. */
time(params?: string | core.$ZodCheckISOTimeParams): this;
/** @deprecated Use `z.iso.duration()` instead. */
duration(params?: string | core.$ZodCheckISODurationParams): this;
}
export declare const ZodString: core.$constructor;
export declare function string(params?: string | core.$ZodStringParams): ZodString;
export declare function string(params?: string | core.$ZodStringParams): core.$ZodType;
export interface ZodStringFormat extends _ZodString> {
}
export declare const ZodStringFormat: core.$constructor;
export interface ZodEmail extends ZodStringFormat<"email"> {
_zod: core.$ZodEmailInternals;
}
export declare const ZodEmail: core.$constructor;
export declare function email(params?: string | core.$ZodEmailParams): ZodEmail;
export interface ZodGUID extends ZodStringFormat<"guid"> {
_zod: core.$ZodGUIDInternals;
}
export declare const ZodGUID: core.$constructor;
export declare function guid(params?: string | core.$ZodGUIDParams): ZodGUID;
export interface ZodUUID extends ZodStringFormat<"uuid"> {
_zod: core.$ZodUUIDInternals;
}
export declare const ZodUUID: core.$constructor;
export declare function uuid(params?: string | core.$ZodUUIDParams): ZodUUID;
export declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodUUID;
export declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodUUID;
export declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodUUID;
export interface ZodURL extends ZodStringFormat<"url"> {
_zod: core.$ZodURLInternals;
}
export declare const ZodURL: core.$constructor;
export declare function url(params?: string | core.$ZodURLParams): ZodURL;
export interface ZodEmoji extends ZodStringFormat<"emoji"> {
_zod: core.$ZodEmojiInternals;
}
export declare const ZodEmoji: core.$constructor;
export declare function emoji(params?: string | core.$ZodEmojiParams): ZodEmoji;
export interface ZodNanoID extends ZodStringFormat<"nanoid"> {
_zod: core.$ZodNanoIDInternals;
}
export declare const ZodNanoID: core.$constructor;
export declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodNanoID;
export interface ZodCUID extends ZodStringFormat<"cuid"> {
_zod: core.$ZodCUIDInternals;
}
export declare const ZodCUID: core.$constructor;
export declare function cuid(params?: string | core.$ZodCUIDParams): ZodCUID;
export interface ZodCUID2 extends ZodStringFormat<"cuid2"> {
_zod: core.$ZodCUID2Internals;
}
export declare const ZodCUID2: core.$constructor;
export declare function cuid2(params?: string | core.$ZodCUID2Params): ZodCUID2;
export interface ZodULID extends ZodStringFormat<"ulid"> {
_zod: core.$ZodULIDInternals;
}
export declare const ZodULID: core.$constructor;
export declare function ulid(params?: string | core.$ZodULIDParams): ZodULID;
export interface ZodXID extends ZodStringFormat<"xid"> {
_zod: core.$ZodXIDInternals;
}
export declare const ZodXID: core.$constructor;
export declare function xid(params?: string | core.$ZodXIDParams): ZodXID;
export interface ZodKSUID extends ZodStringFormat<"ksuid"> {
_zod: core.$ZodKSUIDInternals;
}
export declare const ZodKSUID: core.$constructor;
export declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodKSUID;
export interface ZodIPv4 extends ZodStringFormat<"ipv4"> {
_zod: core.$ZodIPv4Internals;
}
export declare const ZodIPv4: core.$constructor;
export declare function ipv4(params?: string | core.$ZodIPv4Params): ZodIPv4;
export interface ZodIPv6 extends ZodStringFormat<"ipv6"> {
_zod: core.$ZodIPv6Internals;
}
export declare const ZodIPv6: core.$constructor;
export declare function ipv6(params?: string | core.$ZodIPv6Params): ZodIPv6;
export interface ZodCIDRv4 extends ZodStringFormat<"cidrv4"> {
_zod: core.$ZodCIDRv4Internals;
}
export declare const ZodCIDRv4: core.$constructor;
export declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodCIDRv4;
export interface ZodCIDRv6 extends ZodStringFormat<"cidrv6"> {
_zod: core.$ZodCIDRv6Internals;
}
export declare const ZodCIDRv6: core.$constructor;
export declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodCIDRv6;
export interface ZodBase64 extends ZodStringFormat<"base64"> {
_zod: core.$ZodBase64Internals;
}
export declare const ZodBase64: core.$constructor;
export declare function base64(params?: string | core.$ZodBase64Params): ZodBase64;
export interface ZodBase64URL extends ZodStringFormat<"base64url"> {
_zod: core.$ZodBase64URLInternals;
}
export declare const ZodBase64URL: core.$constructor;
export declare function base64url(params?: string | core.$ZodBase64URLParams): ZodBase64URL;
export interface ZodE164 extends ZodStringFormat<"e164"> {
_zod: core.$ZodE164Internals;
}
export declare const ZodE164: core.$constructor;
export declare function e164(params?: string | core.$ZodE164Params): ZodE164;
export interface ZodJWT extends ZodStringFormat<"jwt"> {
_zod: core.$ZodJWTInternals;
}
export declare const ZodJWT: core.$constructor;
export declare function jwt(params?: string | core.$ZodJWTParams): ZodJWT;
export interface ZodCustomStringFormat extends ZodStringFormat, core.$ZodCustomStringFormat {
_zod: core.$ZodCustomStringFormatInternals;
}
export declare const ZodCustomStringFormat: core.$constructor;
export declare function stringFormat(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat;
export interface _ZodNumber extends _ZodType {
gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
/** Identical to .min() */
gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
min(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
lt(value: number, params?: string | core.$ZodCheckLessThanParams): this;
/** Identical to .max() */
lte(value: number, params?: string | core.$ZodCheckLessThanParams): this;
max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
/** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
int(params?: string | core.$ZodCheckNumberFormatParams): this;
/** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
safe(params?: string | core.$ZodCheckNumberFormatParams): this;
positive(params?: string | core.$ZodCheckGreaterThanParams): this;
nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
negative(params?: string | core.$ZodCheckLessThanParams): this;
nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
multipleOf(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
/** @deprecated Use `.multipleOf()` instead. */
step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
/** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
finite(params?: unknown): this;
minValue: number | null;
maxValue: number | null;
/** @deprecated Check the `format` property instead. */
isInt: boolean;
/** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
isFinite: boolean;
format: string | null;
}
export interface ZodNumber extends _ZodNumber> {
}
export declare const ZodNumber: core.$constructor;
export declare function number(params?: string | core.$ZodNumberParams): ZodNumber;
export interface ZodNumberFormat extends ZodNumber {
_zod: core.$ZodNumberFormatInternals;
}
export declare const ZodNumberFormat: core.$constructor;
export interface ZodInt extends ZodNumberFormat {
}
export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodInt;
export interface ZodFloat32 extends ZodNumberFormat {
}
export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat32;
export interface ZodFloat64 extends ZodNumberFormat {
}
export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat64;
export interface ZodInt32 extends ZodNumberFormat {
}
export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodInt32;
export interface ZodUInt32 extends ZodNumberFormat {
}
export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32;
export interface _ZodBoolean extends _ZodType {
}
export interface ZodBoolean extends _ZodBoolean> {
}
export declare const ZodBoolean: core.$constructor;
export declare function boolean(params?: string | core.$ZodBooleanParams): ZodBoolean;
export interface _ZodBigInt extends _ZodType {
gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
/** Alias of `.gte()` */
min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
gt(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
/** Alias of `.lte()` */
lte(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
max(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
lt(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
positive(params?: string | core.$ZodCheckGreaterThanParams): this;
negative(params?: string | core.$ZodCheckLessThanParams): this;
nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
multipleOf(value: bigint, params?: string | core.$ZodCheckMultipleOfParams): this;
minValue: bigint | null;
maxValue: bigint | null;
format: string | null;
}
export interface ZodBigInt extends _ZodBigInt> {
}
export declare const ZodBigInt: core.$constructor;
export declare function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt;
export interface ZodBigIntFormat extends ZodBigInt {
_zod: core.$ZodBigIntFormatInternals;
}
export declare const ZodBigIntFormat: core.$constructor;
export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
export interface ZodSymbol extends _ZodType {
}
export declare const ZodSymbol: core.$constructor;
export declare function symbol(params?: string | core.$ZodSymbolParams): ZodSymbol;
export interface ZodUndefined extends _ZodType {
}
export declare const ZodUndefined: core.$constructor;
declare function _undefined(params?: string | core.$ZodUndefinedParams): ZodUndefined;
export { _undefined as undefined };
export interface ZodNull extends _ZodType {
}
export declare const ZodNull: core.$constructor;
declare function _null(params?: string | core.$ZodNullParams): ZodNull;
export { _null as null };
export interface ZodAny extends _ZodType {
}
export declare const ZodAny: core.$constructor;
export declare function any(): ZodAny;
export interface ZodUnknown extends _ZodType {
}
export declare const ZodUnknown: core.$constructor;
export declare function unknown(): ZodUnknown;
export interface ZodNever extends _ZodType {
}
export declare const ZodNever: core.$constructor;
export declare function never(params?: string | core.$ZodNeverParams): ZodNever;
export interface ZodVoid extends _ZodType {
}
export declare const ZodVoid: core.$constructor;
declare function _void(params?: string | core.$ZodVoidParams): ZodVoid;
export { _void as void };
export interface _ZodDate extends _ZodType {
min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this;
max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this;
/** @deprecated Not recommended. */
minDate: Date | null;
/** @deprecated Not recommended. */
maxDate: Date | null;
}
export interface ZodDate extends _ZodDate> {
}
export declare const ZodDate: core.$constructor;
export declare function date(params?: string | core.$ZodDateParams): ZodDate;
export interface ZodArray extends _ZodType>, core.$ZodArray {
element: T;
min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
unwrap(): T;
}
export declare const ZodArray: core.$constructor;
export declare function array(element: T, params?: string | core.$ZodArrayParams): ZodArray;
export declare function keyof(schema: T): ZodLiteral>;
export interface ZodObject<
/** @ts-ignore Cast variance */
out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _ZodType>, core.$ZodObject {
shape: Shape;
keyof(): ZodEnum>;
/** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
catchall(schema: T): ZodObject>;
/** @deprecated Use `z.looseObject()` or `.loose()` instead. */
passthrough(): ZodObject;
/** Consider `z.looseObject(A.shape)` instead */
loose(): ZodObject;
/** Consider `z.strictObject(A.shape)` instead */
strict(): ZodObject;
/** This is the default behavior. This method call is likely unnecessary. */
strip(): ZodObject;
extend>>(shape: U): ZodObject, Config>;
/**
* @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
*
* ```ts
* const A = z.object({ a: z.string() });
* const B = z.object({ b: z.number() });
*
* const C = z.object({
* ...A.shape,
* ...B.shape
* });
* ```
*/
merge(other: U): ZodObject, U["_zod"]["config"]>;
pick>(mask: M): ZodObject>>, Config>;
omit>(mask: M): ZodObject>>, Config>;
partial(): ZodObject<{
[k in keyof Shape]: ZodOptional;
}, Config>;
partial>(mask: M): ZodObject<{
[k in keyof Shape]: k extends keyof M ? ZodOptional : Shape[k];
}, Config>;
required(): ZodObject<{
[k in keyof Shape]: ZodNonOptional;
}, Config>;
required>(mask: M): ZodObject<{
[k in keyof Shape]: k extends keyof M ? ZodNonOptional : Shape[k];
}, Config>;
}
export declare const ZodObject: core.$constructor;
export declare function object>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject, core.$strip>;
export declare function strictObject(shape: T, params?: string | core.$ZodObjectParams): ZodObject;
export declare function looseObject(shape: T, params?: string | core.$ZodObjectParams): ZodObject;
export interface ZodUnion extends _ZodType>, core.$ZodUnion {
options: T;
}
export declare const ZodUnion: core.$constructor;
export declare function union(options: T, params?: string | core.$ZodUnionParams): ZodUnion;
export interface ZodDiscriminatedUnion extends ZodUnion, core.$ZodDiscriminatedUnion {
_zod: core.$ZodDiscriminatedUnionInternals;
}
export declare const ZodDiscriminatedUnion: core.$constructor;
export declare function discriminatedUnion(discriminator: string, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion;
export interface ZodIntersection extends _ZodType>, core.$ZodIntersection {
}
export declare const ZodIntersection: core.$constructor;
export declare function intersection(left: T, right: U): ZodIntersection;
export interface ZodTuple extends _ZodType>, core.$ZodTuple {
rest(rest: Rest): ZodTuple;
}
export declare const ZodTuple: core.$constructor;
export declare function tuple(items: T, params?: string | core.$ZodTupleParams): ZodTuple;
export declare function tuple(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodTuple;
export declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodTuple<[], null>;
export interface ZodRecord extends _ZodType>, core.$ZodRecord {
keyType: Key;
valueType: Value;
}
export declare const ZodRecord: core.$constructor;
export declare function record(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord;
export declare function partialRecord(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord;
export interface ZodMap extends _ZodType>, core.$ZodMap {
keyType: Key;
valueType: Value;
}
export declare const ZodMap: core.$constructor;
export declare function map(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap;
export interface ZodSet extends _ZodType>, core.$ZodSet {
min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
/** */
nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
}
export declare const ZodSet: core.$constructor;
export declare function set(valueType: Value, params?: string | core.$ZodSetParams): ZodSet;
export interface ZodEnum<
/** @ts-ignore Cast variance */
out T extends util.EnumLike = util.EnumLike> extends _ZodType>, core.$ZodEnum {
enum: T;
options: Array;
extract(values: U, params?: string | core.$ZodEnumParams): ZodEnum>>;
exclude(values: U, params?: string | core.$ZodEnumParams): ZodEnum>>;
}
export declare const ZodEnum: core.$constructor;
declare function _enum(values: T, params?: string | core.$ZodEnumParams): ZodEnum>;
declare function _enum(entries: T, params?: string | core.$ZodEnumParams): ZodEnum;
export { _enum as enum };
/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
*
* ```ts
* enum Colors { red, green, blue }
* z.enum(Colors);
* ```
*/
export declare function nativeEnum(entries: T, params?: string | core.$ZodEnumParams): ZodEnum;
export interface ZodLiteral extends _ZodType>, core.$ZodLiteral {
values: Set;
/** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
value: T;
}
export declare const ZodLiteral: core.$constructor;
export declare function literal>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral;
export declare function literal(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral;
export interface ZodFile extends _ZodType, core.$ZodFile {
min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;
mime(types: util.MimeTypes | Array, params?: string | core.$ZodCheckMimeTypeParams): this;
}
export declare const ZodFile: core.$constructor;
export declare function file(params?: string | core.$ZodFileParams): ZodFile;
export interface ZodTransform extends _ZodType>, core.$ZodTransform {
}
export declare const ZodTransform: core.$constructor