@cossistant/react 0.0.29 → 0.0.30

package/schemas.d.ts

@@ -1,971 +0,0 @@
-import { BaseSchema } from "./json-schema.js";
-import { StandardSchemaV1 } from "./standard-schema.js";
-import { ProcessParams, ToJSONSchemaContext } from "./to-json-schema.js";
-import { AnyFunc, Class, EnumLike, IsAny, JWTAlgorithm, Literal, LoosePartial, MakeReadonly, MaybeAsync, MimeTypes, NoUndefined, Prettify, PrimitiveSet, PropValues, TupleItems } from "./util.js";
-import { version } from "./versions.js";
-import { $ZodCheck, $ZodCheckDef, $ZodCheckInternals, $ZodCheckStringFormatDef, $ZodCheckStringFormatInternals } from "./checks.js";
-import { $ZodErrorMap, $ZodIssue, $ZodIssueBase, $ZodIssueInvalidElement, $ZodIssueInvalidKey, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodRawIssue } from "./errors.js";
-import { $constructor, input, output } from "./core.js";
-
-//#region ../../node_modules/.bun/zod@4.2.1/node_modules/zod/v4/core/schemas.d.cts
-interface ParseContext<T$1 extends $ZodIssueBase = never> {
-  /** Customize error messages. */
-  readonly error?: $ZodErrorMap<T$1>;
-  /** Include the `input` field in issue objects. Default `false`. */
-  readonly reportInput?: boolean;
-  /** Skip eval-based fast path. Default `false`. */
-  readonly jitless?: boolean;
-}
-/** @internal */
-interface ParseContextInternal<T$1 extends $ZodIssueBase = never> extends ParseContext<T$1> {
-  readonly async?: boolean | undefined;
-  readonly direction?: "forward" | "backward";
-  readonly skipChecks?: boolean;
-}
-interface ParsePayload<T$1 = unknown> {
-  value: T$1;
-  issues: $ZodRawIssue[];
-  /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
-  aborted?: boolean;
-}
-type CheckFn<T$1> = (input: ParsePayload<T$1>) => MaybeAsync<void>;
-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" | "function" | "custom";
-  error?: $ZodErrorMap<never> | undefined;
-  checks?: $ZodCheck<never>[];
-}
-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: AnyFunc[] | undefined;
-  /** @internal Parses input and runs all checks (refinements). */
-  run(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
-  /** @internal Parses input, doesn't run checks. */
-  parse(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
-  /** @internal  Stores identifiers for the set of traits implemented by this schema. */
-  traits: Set<string>;
-  /** @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?: PrimitiveSet | undefined;
-  /** Default value bubbled up from  */
-  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
-  propValues?: 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<string, unknown>;
-  /** @internal The set of issues this schema might throw during type checking. */
-  isst: $ZodIssueBase;
-  /** @internal Subject to change, not a public API. */
-  processJSONSchema?: ((ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void) | undefined;
-  /** 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 */
-interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
-  /** @internal The inferred output type */
-  output: O;
-  /** @internal The inferred input type */
-  input: I;
-}
-type $ZodStandardSchema<T$1> = StandardSchemaV1.Props<input<T$1>, output<T$1>>;
-type SomeType = {
-  _zod: _$ZodTypeInternals;
-};
-interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
-  _zod: Internals;
-  "~standard": $ZodStandardSchema<this>;
-}
-interface _$ZodType<T$1 extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T$1["output"], T$1["input"], T$1> {}
-declare const $ZodType: $constructor<$ZodType>;
-interface $ZodStringDef extends $ZodTypeDef {
-  type: "string";
-  coerce?: boolean;
-  checks?: $ZodCheck<string>[];
-}
-interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
-  def: $ZodStringDef;
-  /** @deprecated Internal API, use with caution (not deprecated) */
-  pattern: RegExp;
-  /** @deprecated Internal API, use with caution (not deprecated) */
-  isst: $ZodIssueInvalidType;
-  bag: LoosePartial<{
-    minimum: number;
-    maximum: number;
-    patterns: Set<RegExp>;
-    format: string;
-    contentEncoding: string;
-  }>;
-}
-interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {}
-declare const $ZodString: $constructor<$ZodString>;
-interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
-interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
-  def: $ZodStringFormatDef<Format>;
-}
-interface $ZodStringFormat<Format extends string = string> extends $ZodType {
-  _zod: $ZodStringFormatInternals<Format>;
-}
-declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
-interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
-interface $ZodGUID extends $ZodType {
-  _zod: $ZodGUIDInternals;
-}
-declare const $ZodGUID: $constructor<$ZodGUID>;
-interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
-  version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
-}
-interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
-  def: $ZodUUIDDef;
-}
-interface $ZodUUID extends $ZodType {
-  _zod: $ZodUUIDInternals;
-}
-declare const $ZodUUID: $constructor<$ZodUUID>;
-interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
-interface $ZodEmail extends $ZodType {
-  _zod: $ZodEmailInternals;
-}
-declare const $ZodEmail: $constructor<$ZodEmail>;
-interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
-  hostname?: RegExp | undefined;
-  protocol?: RegExp | undefined;
-  normalize?: boolean | undefined;
-}
-interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
-  def: $ZodURLDef;
-}
-interface $ZodURL extends $ZodType {
-  _zod: $ZodURLInternals;
-}
-declare const $ZodURL: $constructor<$ZodURL>;
-interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
-interface $ZodEmoji extends $ZodType {
-  _zod: $ZodEmojiInternals;
-}
-declare const $ZodEmoji: $constructor<$ZodEmoji>;
-interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {}
-interface $ZodNanoID extends $ZodType {
-  _zod: $ZodNanoIDInternals;
-}
-declare const $ZodNanoID: $constructor<$ZodNanoID>;
-interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
-interface $ZodCUID extends $ZodType {
-  _zod: $ZodCUIDInternals;
-}
-declare const $ZodCUID: $constructor<$ZodCUID>;
-interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {}
-interface $ZodCUID2 extends $ZodType {
-  _zod: $ZodCUID2Internals;
-}
-declare const $ZodCUID2: $constructor<$ZodCUID2>;
-interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {}
-interface $ZodULID extends $ZodType {
-  _zod: $ZodULIDInternals;
-}
-declare const $ZodULID: $constructor<$ZodULID>;
-interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {}
-interface $ZodXID extends $ZodType {
-  _zod: $ZodXIDInternals;
-}
-declare const $ZodXID: $constructor<$ZodXID>;
-interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {}
-interface $ZodKSUID extends $ZodType {
-  _zod: $ZodKSUIDInternals;
-}
-declare const $ZodKSUID: $constructor<$ZodKSUID>;
-interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
-  precision: number | null;
-  offset: boolean;
-  local: boolean;
-}
-interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
-  def: $ZodISODateTimeDef;
-}
-interface $ZodISODateTime extends $ZodType {
-  _zod: $ZodISODateTimeInternals;
-}
-declare const $ZodISODateTime: $constructor<$ZodISODateTime>;
-interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {}
-interface $ZodISODate extends $ZodType {
-  _zod: $ZodISODateInternals;
-}
-declare const $ZodISODate: $constructor<$ZodISODate>;
-interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
-  precision?: number | null;
-}
-interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
-  def: $ZodISOTimeDef;
-}
-interface $ZodISOTime extends $ZodType {
-  _zod: $ZodISOTimeInternals;
-}
-declare const $ZodISOTime: $constructor<$ZodISOTime>;
-interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {}
-interface $ZodISODuration extends $ZodType {
-  _zod: $ZodISODurationInternals;
-}
-declare const $ZodISODuration: $constructor<$ZodISODuration>;
-interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
-  version?: "v4";
-}
-interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
-  def: $ZodIPv4Def;
-}
-interface $ZodIPv4 extends $ZodType {
-  _zod: $ZodIPv4Internals;
-}
-declare const $ZodIPv4: $constructor<$ZodIPv4>;
-interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
-  version?: "v6";
-}
-interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
-  def: $ZodIPv6Def;
-}
-interface $ZodIPv6 extends $ZodType {
-  _zod: $ZodIPv6Internals;
-}
-declare const $ZodIPv6: $constructor<$ZodIPv6>;
-interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
-  version?: "v4";
-}
-interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
-  def: $ZodCIDRv4Def;
-}
-interface $ZodCIDRv4 extends $ZodType {
-  _zod: $ZodCIDRv4Internals;
-}
-declare const $ZodCIDRv4: $constructor<$ZodCIDRv4>;
-interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
-  version?: "v6";
-}
-interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
-  def: $ZodCIDRv6Def;
-}
-interface $ZodCIDRv6 extends $ZodType {
-  _zod: $ZodCIDRv6Internals;
-}
-declare const $ZodCIDRv6: $constructor<$ZodCIDRv6>;
-interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {}
-interface $ZodBase64 extends $ZodType {
-  _zod: $ZodBase64Internals;
-}
-declare const $ZodBase64: $constructor<$ZodBase64>;
-interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {}
-interface $ZodBase64URL extends $ZodType {
-  _zod: $ZodBase64URLInternals;
-}
-declare const $ZodBase64URL: $constructor<$ZodBase64URL>;
-interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {}
-interface $ZodE164 extends $ZodType {
-  _zod: $ZodE164Internals;
-}
-declare const $ZodE164: $constructor<$ZodE164>;
-interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
-  alg?: JWTAlgorithm | undefined;
-}
-interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
-  def: $ZodJWTDef;
-}
-interface $ZodJWT extends $ZodType {
-  _zod: $ZodJWTInternals;
-}
-declare const $ZodJWT: $constructor<$ZodJWT>;
-interface $ZodNumberDef extends $ZodTypeDef {
-  type: "number";
-  coerce?: boolean;
-}
-interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
-  def: $ZodNumberDef;
-  /** @deprecated Internal API, use with caution (not deprecated) */
-  pattern: RegExp;
-  /** @deprecated Internal API, use with caution (not deprecated) */
-  isst: $ZodIssueInvalidType;
-  bag: LoosePartial<{
-    minimum: number;
-    maximum: number;
-    exclusiveMinimum: number;
-    exclusiveMaximum: number;
-    format: string;
-    pattern: RegExp;
-  }>;
-}
-interface $ZodNumber<Input = unknown> extends $ZodType {
-  _zod: $ZodNumberInternals<Input>;
-}
-declare const $ZodNumber: $constructor<$ZodNumber>;
-interface $ZodBooleanDef extends $ZodTypeDef {
-  type: "boolean";
-  coerce?: boolean;
-  checks?: $ZodCheck<boolean>[];
-}
-interface $ZodBooleanInternals<T$1 = unknown> extends $ZodTypeInternals<boolean, T$1> {
-  pattern: RegExp;
-  def: $ZodBooleanDef;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodBoolean<T$1 = unknown> extends $ZodType {
-  _zod: $ZodBooleanInternals<T$1>;
-}
-declare const $ZodBoolean: $constructor<$ZodBoolean>;
-interface $ZodBigIntDef extends $ZodTypeDef {
-  type: "bigint";
-  coerce?: boolean;
-}
-interface $ZodBigIntInternals<T$1 = unknown> extends $ZodTypeInternals<bigint, T$1> {
-  pattern: RegExp;
-  /** @internal Internal API, use with caution */
-  def: $ZodBigIntDef;
-  isst: $ZodIssueInvalidType;
-  bag: LoosePartial<{
-    minimum: bigint;
-    maximum: bigint;
-    format: string;
-  }>;
-}
-interface $ZodBigInt<T$1 = unknown> extends $ZodType {
-  _zod: $ZodBigIntInternals<T$1>;
-}
-declare const $ZodBigInt: $constructor<$ZodBigInt>;
-interface $ZodSymbolDef extends $ZodTypeDef {
-  type: "symbol";
-}
-interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
-  def: $ZodSymbolDef;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodSymbol extends $ZodType {
-  _zod: $ZodSymbolInternals;
-}
-declare const $ZodSymbol: $constructor<$ZodSymbol>;
-interface $ZodUndefinedDef extends $ZodTypeDef {
-  type: "undefined";
-}
-interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
-  pattern: RegExp;
-  def: $ZodUndefinedDef;
-  values: PrimitiveSet;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodUndefined extends $ZodType {
-  _zod: $ZodUndefinedInternals;
-}
-declare const $ZodUndefined: $constructor<$ZodUndefined>;
-interface $ZodNullDef extends $ZodTypeDef {
-  type: "null";
-}
-interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
-  pattern: RegExp;
-  def: $ZodNullDef;
-  values: PrimitiveSet;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodNull extends $ZodType {
-  _zod: $ZodNullInternals;
-}
-declare const $ZodNull: $constructor<$ZodNull>;
-interface $ZodAnyDef extends $ZodTypeDef {
-  type: "any";
-}
-interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
-  def: $ZodAnyDef;
-  isst: never;
-}
-interface $ZodAny extends $ZodType {
-  _zod: $ZodAnyInternals;
-}
-declare const $ZodAny: $constructor<$ZodAny>;
-interface $ZodUnknownDef extends $ZodTypeDef {
-  type: "unknown";
-}
-interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
-  def: $ZodUnknownDef;
-  isst: never;
-}
-interface $ZodUnknown extends $ZodType {
-  _zod: $ZodUnknownInternals;
-}
-declare const $ZodUnknown: $constructor<$ZodUnknown>;
-interface $ZodNeverDef extends $ZodTypeDef {
-  type: "never";
-}
-interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
-  def: $ZodNeverDef;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodNever extends $ZodType {
-  _zod: $ZodNeverInternals;
-}
-declare const $ZodNever: $constructor<$ZodNever>;
-interface $ZodVoidDef extends $ZodTypeDef {
-  type: "void";
-}
-interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
-  def: $ZodVoidDef;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodVoid extends $ZodType {
-  _zod: $ZodVoidInternals;
-}
-declare const $ZodVoid: $constructor<$ZodVoid>;
-interface $ZodDateDef extends $ZodTypeDef {
-  type: "date";
-  coerce?: boolean;
-}
-interface $ZodDateInternals<T$1 = unknown> extends $ZodTypeInternals<Date, T$1> {
-  def: $ZodDateDef;
-  isst: $ZodIssueInvalidType;
-  bag: LoosePartial<{
-    minimum: Date;
-    maximum: Date;
-    format: string;
-  }>;
-}
-interface $ZodDate<T$1 = unknown> extends $ZodType {
-  _zod: $ZodDateInternals<T$1>;
-}
-declare const $ZodDate: $constructor<$ZodDate>;
-interface $ZodArrayDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "array";
-  element: T$1;
-}
-interface $ZodArrayInternals<T$1 extends SomeType = $ZodType> extends _$ZodTypeInternals {
-  def: $ZodArrayDef<T$1>;
-  isst: $ZodIssueInvalidType;
-  output: output<T$1>[];
-  input: input<T$1>[];
-}
-interface $ZodArray<T$1 extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T$1>> {}
-declare const $ZodArray: $constructor<$ZodArray>;
-type OptionalOutSchema = {
-  _zod: {
-    optout: "optional";
-  };
-};
-type OptionalInSchema = {
-  _zod: {
-    optin: "optional";
-  };
-};
-type $InferObjectOutput<T$1 extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T$1 ? IsAny<T$1[keyof T$1]> extends true ? Record<string, unknown> : Record<string, output<T$1[keyof T$1]>> : keyof (T$1 & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T$1 as T$1[k] extends OptionalOutSchema ? never : k]: T$1[k]["_zod"]["output"] } & { -readonly [k in keyof T$1 as T$1[k] extends OptionalOutSchema ? k : never]?: T$1[k]["_zod"]["output"] } & Extra>;
-type $InferObjectInput<T$1 extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T$1 ? IsAny<T$1[keyof T$1]> extends true ? Record<string, unknown> : Record<string, input<T$1[keyof T$1]>> : keyof (T$1 & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T$1 as T$1[k] extends OptionalInSchema ? never : k]: T$1[k]["_zod"]["input"] } & { -readonly [k in keyof T$1 as T$1[k] extends OptionalInSchema ? k : never]?: T$1[k]["_zod"]["input"] } & Extra>;
-type $ZodObjectConfig = {
-  out: Record<string, unknown>;
-  in: Record<string, unknown>;
-};
-type $loose = {
-  out: Record<string, unknown>;
-  in: Record<string, unknown>;
-};
-type $strict = {
-  out: {};
-  in: {};
-};
-type $strip = {
-  out: {};
-  in: {};
-};
-type $catchall<T$1 extends SomeType> = {
-  out: {
-    [k: string]: output<T$1>;
-  };
-  in: {
-    [k: string]: input<T$1>;
-  };
-};
-type $ZodShape = Readonly<{
-  [k: string]: $ZodType;
-}>;
-interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
-  type: "object";
-  shape: Shape;
-  catchall?: $ZodType | undefined;
-}
-interface $ZodObjectInternals< /** @ts-ignore Cast variance */
-out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
-  def: $ZodObjectDef<Shape>;
-  config: Config;
-  isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
-  propValues: PropValues;
-  output: $InferObjectOutput<Shape, Config["out"]>;
-  input: $InferObjectInput<Shape, Config["in"]>;
-  optin?: "optional" | undefined;
-  optout?: "optional" | undefined;
-}
-type $ZodLooseShape = Record<string, any>;
-interface $ZodObject< /** @ts-ignore Cast variance */
-out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {}
-declare const $ZodObject: $constructor<$ZodObject>;
-type $InferUnionOutput<T$1 extends SomeType> = T$1 extends any ? output<T$1> : never;
-type $InferUnionInput<T$1 extends SomeType> = T$1 extends any ? input<T$1> : never;
-interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
-  type: "union";
-  options: Options;
-  inclusive?: boolean;
-}
-type IsOptionalIn<T$1 extends SomeType> = T$1 extends OptionalInSchema ? true : false;
-type IsOptionalOut<T$1 extends SomeType> = T$1 extends OptionalOutSchema ? true : false;
-interface $ZodUnionInternals<T$1 extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
-  def: $ZodUnionDef<T$1>;
-  isst: $ZodIssueInvalidUnion;
-  pattern: T$1[number]["_zod"]["pattern"];
-  values: T$1[number]["_zod"]["values"];
-  output: $InferUnionOutput<T$1[number]>;
-  input: $InferUnionInput<T$1[number]>;
-  optin: IsOptionalIn<T$1[number]> extends false ? "optional" | undefined : "optional";
-  optout: IsOptionalOut<T$1[number]> extends false ? "optional" | undefined : "optional";
-}
-interface $ZodUnion<T$1 extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T$1>> {
-  _zod: $ZodUnionInternals<T$1>;
-}
-declare const $ZodUnion: $constructor<$ZodUnion>;
-interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "intersection";
-  left: Left;
-  right: Right;
-}
-interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
-  def: $ZodIntersectionDef<A, B>;
-  isst: never;
-  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
-  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
-  output: output<A> & output<B>;
-  input: input<A> & input<B>;
-}
-interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodIntersectionInternals<A, B>;
-}
-declare const $ZodIntersection: $constructor<$ZodIntersection>;
-interface $ZodTupleDef<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
-  type: "tuple";
-  items: T$1;
-  rest: Rest$1;
-}
-type $InferTupleInputType<T$1 extends TupleItems, Rest$1 extends SomeType | null> = [...TupleInputTypeWithOptionals<T$1>, ...(Rest$1 extends SomeType ? input<Rest$1>[] : [])];
-type TupleInputTypeNoOptionals<T$1 extends TupleItems> = { [k in keyof T$1]: input<T$1[k]> };
-type TupleInputTypeWithOptionals<T$1 extends TupleItems> = T$1 extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, input<Tail>?] : TupleInputTypeNoOptionals<T$1> : [];
-type $InferTupleOutputType<T$1 extends TupleItems, Rest$1 extends SomeType | null> = [...TupleOutputTypeWithOptionals<T$1>, ...(Rest$1 extends SomeType ? output<Rest$1>[] : [])];
-type TupleOutputTypeNoOptionals<T$1 extends TupleItems> = { [k in keyof T$1]: output<T$1[k]> };
-type TupleOutputTypeWithOptionals<T$1 extends TupleItems> = T$1 extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output<Tail>?] : TupleOutputTypeNoOptionals<T$1> : [];
-interface $ZodTupleInternals<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
-  def: $ZodTupleDef<T$1, Rest$1>;
-  isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
-  output: $InferTupleOutputType<T$1, Rest$1>;
-  input: $InferTupleInputType<T$1, Rest$1>;
-}
-interface $ZodTuple<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends $ZodType {
-  _zod: $ZodTupleInternals<T$1, Rest$1>;
-}
-declare const $ZodTuple: $constructor<$ZodTuple>;
-type $ZodRecordKey = $ZodType<string | number | symbol, string | number | symbol>;
-interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "record";
-  keyType: Key;
-  valueType: Value;
-  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
-  mode?: "strict" | "loose";
-}
-type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
-type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key>, input<Value>>> : Record<input<Key>, input<Value>>;
-interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
-  def: $ZodRecordDef<Key, Value>;
-  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
-  optin?: "optional" | undefined;
-  optout?: "optional" | undefined;
-}
-type $partial = {
-  "~~partial": true;
-};
-interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodRecordInternals<Key, Value>;
-}
-declare const $ZodRecord: $constructor<$ZodRecord>;
-interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "map";
-  keyType: Key;
-  valueType: Value;
-}
-interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key>, output<Value>>, Map<input<Key>, input<Value>>> {
-  def: $ZodMapDef<Key, Value>;
-  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
-  optin?: "optional" | undefined;
-  optout?: "optional" | undefined;
-}
-interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodMapInternals<Key, Value>;
-}
-declare const $ZodMap: $constructor<$ZodMap>;
-interface $ZodSetDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "set";
-  valueType: T$1;
-}
-interface $ZodSetInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T$1>>, Set<input<T$1>>> {
-  def: $ZodSetDef<T$1>;
-  isst: $ZodIssueInvalidType;
-  optin?: "optional" | undefined;
-  optout?: "optional" | undefined;
-}
-interface $ZodSet<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodSetInternals<T$1>;
-}
-declare const $ZodSet: $constructor<$ZodSet>;
-type $InferEnumOutput<T$1 extends EnumLike> = T$1[keyof T$1] & {};
-type $InferEnumInput<T$1 extends EnumLike> = T$1[keyof T$1] & {};
-interface $ZodEnumDef<T$1 extends EnumLike = EnumLike> extends $ZodTypeDef {
-  type: "enum";
-  entries: T$1;
-}
-interface $ZodEnumInternals< /** @ts-ignore Cast variance */
-out T$1 extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T$1>, $InferEnumInput<T$1>> {
-  def: $ZodEnumDef<T$1>;
-  /** @deprecated Internal API, use with caution (not deprecated) */
-  values: PrimitiveSet;
-  /** @deprecated Internal API, use with caution (not deprecated) */
-  pattern: RegExp;
-  isst: $ZodIssueInvalidValue;
-}
-interface $ZodEnum<T$1 extends EnumLike = EnumLike> extends $ZodType {
-  _zod: $ZodEnumInternals<T$1>;
-}
-declare const $ZodEnum: $constructor<$ZodEnum>;
-interface $ZodLiteralDef<T$1 extends Literal> extends $ZodTypeDef {
-  type: "literal";
-  values: T$1[];
-}
-interface $ZodLiteralInternals<T$1 extends Literal = Literal> extends $ZodTypeInternals<T$1, T$1> {
-  def: $ZodLiteralDef<T$1>;
-  values: Set<T$1>;
-  pattern: RegExp;
-  isst: $ZodIssueInvalidValue;
-}
-interface $ZodLiteral<T$1 extends Literal = Literal> extends $ZodType {
-  _zod: $ZodLiteralInternals<T$1>;
-}
-declare const $ZodLiteral: $constructor<$ZodLiteral>;
-type _File = typeof globalThis extends {
-  File: infer F extends new (...args: any[]) => any;
-} ? InstanceType<F> : {};
-/** Do not reference this directly. */
-interface File extends _File {
-  readonly type: string;
-  readonly size: number;
-}
-interface $ZodFileDef extends $ZodTypeDef {
-  type: "file";
-}
-interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
-  def: $ZodFileDef;
-  isst: $ZodIssueInvalidType;
-  bag: LoosePartial<{
-    minimum: number;
-    maximum: number;
-    mime: MimeTypes[];
-  }>;
-}
-interface $ZodFile extends $ZodType {
-  _zod: $ZodFileInternals;
-}
-declare const $ZodFile: $constructor<$ZodFile>;
-interface $ZodTransformDef extends $ZodTypeDef {
-  type: "transform";
-  transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
-}
-interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
-  def: $ZodTransformDef;
-  isst: never;
-}
-interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
-  _zod: $ZodTransformInternals<O, I>;
-}
-declare const $ZodTransform: $constructor<$ZodTransform>;
-interface $ZodOptionalDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "optional";
-  innerType: T$1;
-}
-interface $ZodOptionalInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1> | undefined, input<T$1> | undefined> {
-  def: $ZodOptionalDef<T$1>;
-  optin: "optional";
-  optout: "optional";
-  isst: never;
-  values: T$1["_zod"]["values"];
-  pattern: T$1["_zod"]["pattern"];
-}
-interface $ZodOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodOptionalInternals<T$1>;
-}
-declare const $ZodOptional: $constructor<$ZodOptional>;
-interface $ZodNullableDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "nullable";
-  innerType: T$1;
-}
-interface $ZodNullableInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1> | null, input<T$1> | null> {
-  def: $ZodNullableDef<T$1>;
-  optin: T$1["_zod"]["optin"];
-  optout: T$1["_zod"]["optout"];
-  isst: never;
-  values: T$1["_zod"]["values"];
-  pattern: T$1["_zod"]["pattern"];
-}
-interface $ZodNullable<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodNullableInternals<T$1>;
-}
-declare const $ZodNullable: $constructor<$ZodNullable>;
-interface $ZodDefaultDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "default";
-  innerType: T$1;
-  /** The default value. May be a getter. */
-  defaultValue: NoUndefined<output<T$1>>;
-}
-interface $ZodDefaultInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, input<T$1> | undefined> {
-  def: $ZodDefaultDef<T$1>;
-  optin: "optional";
-  optout?: "optional" | undefined;
-  isst: never;
-  values: T$1["_zod"]["values"];
-}
-interface $ZodDefault<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodDefaultInternals<T$1>;
-}
-declare const $ZodDefault: $constructor<$ZodDefault>;
-interface $ZodPrefaultDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "prefault";
-  innerType: T$1;
-  /** The default value. May be a getter. */
-  defaultValue: input<T$1>;
-}
-interface $ZodPrefaultInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, input<T$1> | undefined> {
-  def: $ZodPrefaultDef<T$1>;
-  optin: "optional";
-  optout?: "optional" | undefined;
-  isst: never;
-  values: T$1["_zod"]["values"];
-}
-interface $ZodPrefault<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodPrefaultInternals<T$1>;
-}
-declare const $ZodPrefault: $constructor<$ZodPrefault>;
-interface $ZodNonOptionalDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "nonoptional";
-  innerType: T$1;
-}
-interface $ZodNonOptionalInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, NoUndefined<input<T$1>>> {
-  def: $ZodNonOptionalDef<T$1>;
-  isst: $ZodIssueInvalidType;
-  values: T$1["_zod"]["values"];
-  optin: "optional" | undefined;
-  optout: "optional" | undefined;
-}
-interface $ZodNonOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodNonOptionalInternals<T$1>;
-}
-declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
-interface $ZodSuccessDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "success";
-  innerType: T$1;
-}
-interface $ZodSuccessInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T$1>> {
-  def: $ZodSuccessDef<T$1>;
-  isst: never;
-  optin: T$1["_zod"]["optin"];
-  optout: "optional" | undefined;
-}
-interface $ZodSuccess<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodSuccessInternals<T$1>;
-}
-declare const $ZodSuccess: $constructor<$ZodSuccess>;
-interface $ZodCatchCtx extends ParsePayload {
-  /** @deprecated Use `ctx.issues` */
-  error: {
-    issues: $ZodIssue[];
-  };
-  /** @deprecated Use `ctx.value` */
-  input: unknown;
-}
-interface $ZodCatchDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "catch";
-  innerType: T$1;
-  catchValue: (ctx: $ZodCatchCtx) => unknown;
-}
-interface $ZodCatchInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1>, input<T$1>> {
-  def: $ZodCatchDef<T$1>;
-  optin: T$1["_zod"]["optin"];
-  optout: T$1["_zod"]["optout"];
-  isst: never;
-  values: T$1["_zod"]["values"];
-}
-interface $ZodCatch<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodCatchInternals<T$1>;
-}
-declare const $ZodCatch: $constructor<$ZodCatch>;
-interface $ZodNaNDef extends $ZodTypeDef {
-  type: "nan";
-}
-interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
-  def: $ZodNaNDef;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodNaN extends $ZodType {
-  _zod: $ZodNaNInternals;
-}
-declare const $ZodNaN: $constructor<$ZodNaN>;
-interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "pipe";
-  in: A;
-  out: B;
-  /** Only defined inside $ZodCodec instances. */
-  transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
-  /** Only defined inside $ZodCodec instances. */
-  reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
-}
-interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
-  def: $ZodPipeDef<A, B>;
-  isst: never;
-  values: A["_zod"]["values"];
-  optin: A["_zod"]["optin"];
-  optout: B["_zod"]["optout"];
-  propValues: A["_zod"]["propValues"];
-}
-interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodPipeInternals<A, B>;
-}
-declare const $ZodPipe: $constructor<$ZodPipe>;
-interface $ZodReadonlyDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "readonly";
-  innerType: T$1;
-}
-interface $ZodReadonlyInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T$1>>, MakeReadonly<input<T$1>>> {
-  def: $ZodReadonlyDef<T$1>;
-  optin: T$1["_zod"]["optin"];
-  optout: T$1["_zod"]["optout"];
-  isst: never;
-  propValues: T$1["_zod"]["propValues"];
-  values: T$1["_zod"]["values"];
-}
-interface $ZodReadonly<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodReadonlyInternals<T$1>;
-}
-declare const $ZodReadonly: $constructor<$ZodReadonly>;
-interface $ZodTemplateLiteralDef extends $ZodTypeDef {
-  type: "template_literal";
-  parts: $ZodTemplateLiteralPart[];
-  format?: string | undefined;
-}
-interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
-  pattern: RegExp;
-  def: $ZodTemplateLiteralDef;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
-  _zod: $ZodTemplateLiteralInternals<Template>;
-}
-type LiteralPart = Exclude<Literal, symbol>;
-interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
-  pattern: RegExp;
-}
-interface SchemaPart extends $ZodType {
-  _zod: SchemaPartInternals;
-}
-type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
-declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
-type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
-type $ZodFunctionIn = $ZodFunctionArgs;
-type $ZodFunctionOut = $ZodType;
-type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
-type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => MaybeAsync<input<Returns>>;
-type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
-type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => MaybeAsync<output<Returns>>;
-interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
-  type: "function";
-  input: In;
-  output: Out;
-}
-interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
-  def: $ZodFunctionDef<Args, Returns>;
-  isst: $ZodIssueInvalidType;
-}
-interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
-  /** @deprecated */
-  _def: $ZodFunctionDef<Args, Returns>;
-  _input: $InferInnerFunctionType<Args, Returns>;
-  _output: $InferOuterFunctionType<Args, Returns>;
-  implement<F$1 extends $InferInnerFunctionType<Args, Returns>>(func: F$1): (...args: Parameters<this["_output"]>) => ReturnType<F$1> extends ReturnType<this["_output"]> ? ReturnType<F$1> : ReturnType<this["_output"]>;
-  implementAsync<F$1 extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F$1): F$1 extends $InferOuterFunctionTypeAsync<Args, Returns> ? F$1 : $InferOuterFunctionTypeAsync<Args, Returns>;
-  input<const Items extends TupleItems, const Rest$1 extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest$1): $ZodFunction<$ZodTuple<Items, Rest$1>, Returns>;
-  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
-  input(...args: any[]): $ZodFunction<any, Returns>;
-  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
-}
-declare const $ZodFunction: $constructor<$ZodFunction>;
-interface $ZodPromiseDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "promise";
-  innerType: T$1;
-}
-interface $ZodPromiseInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T$1>>, MaybeAsync<input<T$1>>> {
-  def: $ZodPromiseDef<T$1>;
-  isst: never;
-}
-interface $ZodPromise<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodPromiseInternals<T$1>;
-}
-declare const $ZodPromise: $constructor<$ZodPromise>;
-interface $ZodLazyDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
-  type: "lazy";
-  getter: () => T$1;
-}
-interface $ZodLazyInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1>, input<T$1>> {
-  def: $ZodLazyDef<T$1>;
-  isst: never;
-  /** Auto-cached way to retrieve the inner schema */
-  innerType: T$1;
-  pattern: T$1["_zod"]["pattern"];
-  propValues: T$1["_zod"]["propValues"];
-  optin: T$1["_zod"]["optin"];
-  optout: T$1["_zod"]["optout"];
-}
-interface $ZodLazy<T$1 extends SomeType = $ZodType> extends $ZodType {
-  _zod: $ZodLazyInternals<T$1>;
-}
-declare const $ZodLazy: $constructor<$ZodLazy>;
-interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
-  type: "custom";
-  check: "custom";
-  path?: PropertyKey[] | undefined;
-  error?: $ZodErrorMap | undefined;
-  params?: Record<string, any> | undefined;
-  fn: (arg: O) => unknown;
-}
-interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
-  def: $ZodCustomDef;
-  issc: $ZodIssue;
-  isst: never;
-  bag: LoosePartial<{
-    Class: typeof Class;
-  }>;
-}
-interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
-  _zod: $ZodCustomInternals<O, I>;
-}
-declare const $ZodCustom: $constructor<$ZodCustom>;
-type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
-//#endregion
-export { $ZodArray, $ZodArrayInternals, $ZodBase64, $ZodBase64URL, $ZodBooleanInternals, $ZodCIDRv4, $ZodCIDRv6, $ZodCUID, $ZodCUID2, $ZodCatch, $ZodCatchCtx, $ZodCatchInternals, $ZodCustom, $ZodDefault, $ZodDefaultInternals, $ZodE164, $ZodEmail, $ZodEmailInternals, $ZodEmoji, $ZodEnum, $ZodEnumInternals, $ZodGUID, $ZodIPv4, $ZodIPv6, $ZodISODate, $ZodISODateTime, $ZodISODuration, $ZodISOTime, $ZodIntersection, $ZodIntersectionInternals, $ZodJWT, $ZodKSUID, $ZodLiteral, $ZodLiteralInternals, $ZodLooseShape, $ZodNanoID, $ZodNonOptional, $ZodNonOptionalInternals, $ZodNullInternals, $ZodNullable, $ZodNullableInternals, $ZodNumberInternals, $ZodObject, $ZodObjectConfig, $ZodObjectInternals, $ZodOptional, $ZodOptionalInternals, $ZodPipe, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultInternals, $ZodReadonly, $ZodReadonlyInternals, $ZodRecord, $ZodRecordInternals, $ZodRecordKey, $ZodShape, $ZodStringFormat, $ZodStringFormatInternals, $ZodStringInternals, $ZodTransform, $ZodTransformInternals, $ZodType, $ZodTypeInternals, $ZodTypes, $ZodULID, $ZodULIDInternals, $ZodURL, $ZodURLInternals, $ZodUUID, $ZodUnion, $ZodUnionInternals, $ZodUnknownInternals, $ZodXID, $catchall, $loose, $strict, $strip, CheckFn, ParseContext, ParsePayload, SomeType };
-//# sourceMappingURL=schemas.d.ts.map