@rexeus/typeweaver-clients 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1618 @@
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+
+type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type MakePartial<T, K extends keyof T> = Omit$1<T, K> & InexactPartial<Pick<T, K>>;
+type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+type NoUndefined<T> = T extends undefined ? never : T;
+type Whatever = {} | undefined | null;
+type LoosePartial<T extends object> = InexactPartial<T> & {
+    [k: string]: unknown;
+};
+type Mask<Keys extends PropertyKey> = {
+    [K in Keys]?: true;
+};
+type InexactPartial<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+    readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type SomeObject = Record<PropertyKey, any>;
+type Identity<T> = T;
+type Flatten<T> = Identity<{
+    [k in keyof T]: T[k];
+}>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {
+    [K in keyof A as K extends keyof B ? never : K]: A[K];
+} & {
+    [K in keyof B]: B[K];
+}>;
+type AnyFunc = (...args: any[]) => any;
+type MaybeAsync<T> = T | Promise<T>;
+type EnumValue = string | number;
+type EnumLike = Readonly<Record<string, EnumValue>>;
+type ToEnum<T extends EnumValue> = Flatten<{
+    [k in T]: k;
+}>;
+type Literal = string | number | bigint | boolean | null | undefined;
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength = {
+    length: number;
+};
+type PropValues = Record<string, Set<Primitive>>;
+type PrimitiveSet = Set<Primitive>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+    constructor(..._args: any[]);
+}
+
+declare const version: {
+    readonly major: 4;
+    readonly minor: 0;
+    readonly patch: number;
+};
+
+interface ParseContext<T extends $ZodIssueBase = never> {
+    /** Customize error messages. */
+    readonly error?: $ZodErrorMap<T>;
+    /** 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 extends $ZodIssueBase = never> extends ParseContext<T> {
+    readonly async?: boolean | undefined;
+}
+interface ParsePayload<T = unknown> {
+    value: T;
+    issues: $ZodRawIssue[];
+}
+type CheckFn<T> = (input: ParsePayload<T>) => 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" | "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. */
+    id: string;
+    /** @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;
+    /** @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;
+    /** 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> = StandardSchemaV1.Props<input<T>, output<T>>;
+type SomeType = {
+    _zod: _$ZodTypeInternals;
+};
+interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+    _zod: Internals;
+    "~standard": $ZodStandardSchema<this>;
+}
+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 $ZodStringFormatDef<Format extends $ZodStringFormats = $ZodStringFormats> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {
+}
+interface $ZodStringFormatInternals<Format extends $ZodStringFormats = $ZodStringFormats> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
+    def: $ZodStringFormatDef<Format>;
+}
+interface $ZodStringFormat<Format extends $ZodStringFormats = $ZodStringFormats> 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;
+}
+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 $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "array";
+    element: T;
+}
+interface $ZodArrayInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>[], input<T>[]> {
+    def: $ZodArrayDef<T>;
+    isst: $ZodIssueInvalidType;
+}
+interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<output<T>[], input<T>[], $ZodArrayInternals<T>> {
+}
+declare const $ZodArray: $constructor<$ZodArray>;
+type OptionalOutSchema = {
+    _zod: {
+        optout: "optional";
+    };
+};
+type OptionalInSchema = {
+    _zod: {
+        optin: "optional";
+    };
+};
+type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? Record<string, unknown> : keyof (T & Extra) extends never ? Record<string, never> : 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>;
+type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? Record<string, unknown> : keyof (T & Extra) extends never ? Record<string, never> : 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>;
+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 extends SomeType> = {
+    out: {
+        [k: string]: output<T>;
+    };
+    in: {
+        [k: string]: input<T>;
+    };
+};
+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 Readonly<$ZodShape> = Readonly<$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"]>;
+}
+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>> {
+    "~standard": $ZodStandardSchema<this>;
+}
+declare const $ZodObject: $constructor<$ZodObject>;
+type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
+type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
+interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
+    type: "union";
+    options: Options;
+}
+interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
+    def: $ZodUnionDef<T>;
+    isst: $ZodIssueInvalidUnion;
+    pattern: T[number]["_zod"]["pattern"];
+}
+interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
+    _zod: $ZodUnionInternals<T>;
+}
+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<output<A> & output<B>, input<A> & input<B>> {
+    def: $ZodIntersectionDef<A, B>;
+    isst: never;
+}
+interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodIntersectionInternals<A, B>;
+}
+declare const $ZodIntersection: $constructor<$ZodIntersection>;
+type $InferEnumOutput<T extends EnumLike> = T[keyof T] & {};
+type $InferEnumInput<T extends EnumLike> = T[keyof T] & {};
+interface $ZodEnumDef<T extends EnumLike = EnumLike> extends $ZodTypeDef {
+    type: "enum";
+    entries: T;
+}
+interface $ZodEnumInternals<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
+    def: $ZodEnumDef<T>;
+    /** @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 extends EnumLike = EnumLike> extends $ZodType {
+    _zod: $ZodEnumInternals<T>;
+}
+declare const $ZodEnum: $constructor<$ZodEnum>;
+interface $ZodLiteralDef<T extends Literal> extends $ZodTypeDef {
+    type: "literal";
+    values: T[];
+}
+interface $ZodLiteralInternals<T extends Literal = Literal> extends $ZodTypeInternals<T, T> {
+    def: $ZodLiteralDef<T>;
+    values: Set<T>;
+    pattern: RegExp;
+    isst: $ZodIssueInvalidValue;
+}
+interface $ZodLiteral<T extends Literal = Literal> extends $ZodType {
+    _zod: $ZodLiteralInternals<T>;
+}
+declare const $ZodLiteral: $constructor<$ZodLiteral>;
+declare global {
+    interface File {
+    }
+}
+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 extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "optional";
+    innerType: T;
+}
+interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | undefined, input<T> | undefined> {
+    def: $ZodOptionalDef<T>;
+    optin: "optional";
+    optout: "optional";
+    isst: never;
+    values: T["_zod"]["values"];
+    pattern: T["_zod"]["pattern"];
+}
+interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodOptionalInternals<T>;
+}
+declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "nullable";
+    innerType: T;
+}
+interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | null, input<T> | null> {
+    def: $ZodNullableDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    isst: never;
+    values: T["_zod"]["values"];
+    pattern: T["_zod"]["pattern"];
+}
+interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodNullableInternals<T>;
+}
+declare const $ZodNullable: $constructor<$ZodNullable>;
+interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "default";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: NoUndefined<output<T>>;
+}
+interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+    def: $ZodDefaultDef<T>;
+    optin: "optional";
+    isst: never;
+    values: T["_zod"]["values"];
+}
+interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodDefaultInternals<T>;
+}
+declare const $ZodDefault: $constructor<$ZodDefault>;
+interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "prefault";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: input<T>;
+}
+interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+    def: $ZodPrefaultDef<T>;
+    optin: "optional";
+    isst: never;
+    values: T["_zod"]["values"];
+}
+interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodPrefaultInternals<T>;
+}
+declare const $ZodPrefault: $constructor<$ZodPrefault>;
+interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "nonoptional";
+    innerType: T;
+}
+interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, NoUndefined<input<T>>> {
+    def: $ZodNonOptionalDef<T>;
+    isst: $ZodIssueInvalidType;
+    values: T["_zod"]["values"];
+}
+interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodNonOptionalInternals<T>;
+}
+declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodCatchCtx extends ParsePayload {
+    /** @deprecated Use `ctx.issues` */
+    error: {
+        issues: $ZodIssue[];
+    };
+    /** @deprecated Use `ctx.value` */
+    input: unknown;
+}
+interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "catch";
+    innerType: T;
+    catchValue: (ctx: $ZodCatchCtx) => unknown;
+}
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T> | Whatever> {
+    def: $ZodCatchDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    isst: never;
+    values: T["_zod"]["values"];
+}
+interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodCatchInternals<T>;
+}
+declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "pipe";
+    in: A;
+    out: B;
+}
+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"];
+}
+interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodPipeInternals<A, B>;
+}
+declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+    type: "readonly";
+    innerType: T;
+}
+interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T>>, MakeReadonly<input<T>>> {
+    def: $ZodReadonlyDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    isst: never;
+    propValues: T["_zod"]["propValues"];
+}
+interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
+    _zod: $ZodReadonlyInternals<T>;
+}
+declare const $ZodReadonly: $constructor<$ZodReadonly>;
+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>;
+
+interface $ZodCheckDef {
+    check: string;
+    error?: $ZodErrorMap<never> | undefined;
+    /** If true, no later checks will be executed if this check fails. Default `false`. */
+    abort?: boolean | undefined;
+}
+interface $ZodCheckInternals<T> {
+    def: $ZodCheckDef;
+    /** The set of issues this check might throw. */
+    issc?: $ZodIssueBase;
+    check(payload: ParsePayload<T>): MaybeAsync<void>;
+    onattach: ((schema: $ZodType) => void)[];
+    when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+interface $ZodCheck<in T = never> {
+    _zod: $ZodCheckInternals<T>;
+}
+declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+    check: "max_length";
+    maximum: number;
+}
+interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMaxLengthDef;
+    issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckMaxLengthInternals<T>;
+}
+declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+    check: "min_length";
+    minimum: number;
+}
+interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckMinLengthDef;
+    issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckMinLengthInternals<T>;
+}
+declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+    check: "length_equals";
+    length: number;
+}
+interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+    def: $ZodCheckLengthEqualsDef;
+    issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+    _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+interface $ZodCheckStringFormatDef<Format extends $ZodStringFormats = $ZodStringFormats> extends $ZodCheckDef {
+    check: "string_format";
+    format: Format;
+    pattern?: RegExp | undefined;
+}
+interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckStringFormatDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
+    format: "regex";
+    pattern: RegExp;
+}
+interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckRegexDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckRegex extends $ZodCheck<string> {
+    _zod: $ZodCheckRegexInternals;
+}
+declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
+interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
+}
+interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckLowerCaseDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckLowerCase extends $ZodCheck<string> {
+    _zod: $ZodCheckLowerCaseInternals;
+}
+declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
+interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
+}
+interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckUpperCaseDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckUpperCase extends $ZodCheck<string> {
+    _zod: $ZodCheckUpperCaseInternals;
+}
+declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
+interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
+    includes: string;
+    position?: number | undefined;
+}
+interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckIncludesDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckIncludes extends $ZodCheck<string> {
+    _zod: $ZodCheckIncludesInternals;
+}
+declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
+interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
+    prefix: string;
+}
+interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckStartsWithDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckStartsWith extends $ZodCheck<string> {
+    _zod: $ZodCheckStartsWithInternals;
+}
+declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
+interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
+    suffix: string;
+}
+interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
+    def: $ZodCheckEndsWithDef;
+    issc: $ZodIssueInvalidStringFormat;
+}
+interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
+    _zod: $ZodCheckEndsWithInternals;
+}
+declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
+
+interface $ZodIssueBase {
+    readonly code?: string;
+    readonly input?: unknown;
+    readonly path: PropertyKey[];
+    readonly message: string;
+}
+interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_type";
+    readonly expected: $ZodType["_zod"]["def"]["type"];
+    readonly input: Input;
+}
+interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
+    readonly code: "too_big";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly maximum: number | bigint;
+    readonly inclusive?: boolean;
+    readonly input: Input;
+}
+interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
+    readonly code: "too_small";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly minimum: number | bigint;
+    readonly inclusive?: boolean;
+    readonly input: Input;
+}
+interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
+    readonly code: "invalid_format";
+    readonly format: $ZodStringFormats | (string & {});
+    readonly pattern?: string;
+    readonly input: string;
+}
+interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
+    readonly code: "not_multiple_of";
+    readonly divisor: number;
+    readonly input: Input;
+}
+interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
+    readonly code: "unrecognized_keys";
+    readonly keys: string[];
+    readonly input: Record<string, unknown>;
+}
+interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+    readonly code: "invalid_union";
+    readonly errors: $ZodIssue[][];
+    readonly input: unknown;
+}
+interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_key";
+    readonly origin: "map" | "record";
+    readonly issues: $ZodIssue[];
+    readonly input: Input;
+}
+interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_element";
+    readonly origin: "map" | "set";
+    readonly key: unknown;
+    readonly issues: $ZodIssue[];
+    readonly input: Input;
+}
+interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_value";
+    readonly values: Primitive[];
+    readonly input: Input;
+}
+interface $ZodIssueCustom extends $ZodIssueBase {
+    readonly code: "custom";
+    readonly params?: Record<string, any> | undefined;
+    readonly input: unknown;
+}
+type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = Flatten<MakePartial<T, "message" | "path"> & {
+    /** The input data */
+    readonly input?: unknown;
+    /** The schema or check that originated this issue. */
+    readonly inst?: $ZodType | $ZodCheck;
+    /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
+    readonly continue?: boolean | undefined;
+} & Record<string, any>>;
+interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+    (issue: $ZodRawIssue<T>): {
+        message: string;
+    } | string | undefined | null;
+}
+interface $ZodError<T = unknown> extends Error {
+    type: T;
+    issues: $ZodIssue[];
+    _zod: {
+        output: T;
+        def: $ZodIssue[];
+    };
+    stack?: string;
+    name: string;
+}
+declare const $ZodError: $constructor<$ZodError>;
+type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in keyof T]?: U[];
+    };
+};
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: $ZodFormattedError<T[K], U>;
+} : T extends any[] ? {
+    [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? Flatten<{
+    [K in keyof T]?: $ZodFormattedError<T[K], U>;
+}> : any;
+type $ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & Flatten<_ZodFormattedError<T, U>>;
+
+type ZodTrait = {
+    _zod: {
+        def: any;
+        [k: string]: any;
+    };
+};
+interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+    new (def: D): T;
+    init(inst: T, def: D): asserts inst is T;
+}
+declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
+    Parent?: typeof Class;
+}): $constructor<T, D>;
+declare const $brand: unique symbol;
+type $brand<T extends string | number | symbol = string | number | symbol> = {
+    [$brand]: {
+        [k in T]: true;
+    };
+};
+type $ZodBranded<T extends SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
+type input<T> = T extends {
+    _zod: {
+        input: any;
+    };
+} ? Required<T["_zod"]>["input"] : unknown;
+type output<T> = T extends {
+    _zod: {
+        output: any;
+    };
+} ? Required<T["_zod"]>["output"] : unknown;
+
+declare const $output: unique symbol;
+type $output = typeof $output;
+declare const $input: unique symbol;
+type $input = typeof $input;
+type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
+    [K in keyof P]: $replace<P[K], S>;
+}) => $replace<R, S> : Meta extends object ? {
+    [K in keyof Meta]: $replace<Meta[K], S>;
+} : Meta;
+type MetadataType = Record<string, unknown> | undefined;
+declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
+    _meta: Meta;
+    _schema: Schema;
+    _map: WeakMap<Schema, $replace<Meta, Schema>>;
+    _idmap: Map<string, Schema>;
+    add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+    remove(schema: Schema): this;
+    get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
+    has(schema: Schema): boolean;
+}
+interface JSONSchemaMeta {
+    id?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    example?: unknown | undefined;
+    examples?: unknown[] | Record<string, {
+        value: unknown;
+        [k: string]: unknown;
+    }> | undefined;
+    deprecated?: boolean | undefined;
+    [k: string]: unknown;
+}
+interface GlobalMeta extends JSONSchemaMeta {
+}
+
+type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+    error?: string | $ZodErrorMap<IssueTypes> | undefined;
+    /** @deprecated This parameter is deprecated. Use `error` instead. */
+    message?: string | undefined;
+})>>>;
+type TypeParams<T extends $ZodType = $ZodType & {
+    _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+type CheckParams<T extends $ZodCheck = $ZodCheck, // & { _issc: never },
+AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+type CheckStringFormatParams<T extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
+type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail>;
+type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern">;
+type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern">;
+type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL>;
+type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji>;
+type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID>;
+type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID>;
+type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2>;
+type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID>;
+type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID>;
+type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID>;
+type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern">;
+type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern">;
+type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern">;
+type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern">;
+type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern">;
+type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern">;
+type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164>;
+type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern">;
+type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern">;
+type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern">;
+type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern">;
+type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration>;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length">;
+type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern">;
+type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format">;
+type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format">;
+type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "pattern">;
+type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "pattern">;
+type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern">;
+type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
+type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    format(): $ZodFormattedError<T>;
+    format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+    /** @deprecated Use the `z.treeifyError(err)` function instead. */
+    flatten(): $ZodFlattenedError<T>;
+    flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssue(issue: $ZodIssue): void;
+    /** @deprecated Push directly to `.issues` instead. */
+    addIssues(issues: $ZodIssue[]): void;
+    /** @deprecated Check `err.issues.length === 0` instead. */
+    isEmpty: boolean;
+}
+declare const ZodError: $constructor<ZodError>;
+
+type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+type ZodSafeParseSuccess<T> = {
+    success: true;
+    data: T;
+    error?: never;
+};
+type ZodSafeParseError<T> = {
+    success: false;
+    data?: never;
+    error: ZodError<T>;
+};
+
+interface RefinementCtx<T = unknown> extends ParsePayload<T> {
+    addIssue(arg: string | $ZodRawIssue | Partial<$ZodIssueCustom>): void;
+}
+interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {
+}
+interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
+    def: Internals["def"];
+    type: Internals["def"]["type"];
+    /** @deprecated Use `.def` instead. */
+    _def: Internals["def"];
+    /** @deprecated Use `z.output<typeof schema>` instead. */
+    _output: Internals["output"];
+    /** @deprecated Use `z.input<typeof schema>` instead. */
+    _input: Internals["input"];
+    check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+    clone(def?: Internals["def"], params?: {
+        parent: boolean;
+    }): this;
+    register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+    brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T>;
+    parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
+    safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+    parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+    safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+    spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
+    refine(check: (arg: output<this>) => unknown | Promise<unknown>, params?: string | $ZodCustomParams): this;
+    /** @deprecated Use `.check()` instead. */
+    superRefine(refinement: (arg: output<this>, ctx: RefinementCtx<output<this>>) => void | Promise<void>): this;
+    overwrite(fn: (x: output<this>) => output<this>): this;
+    optional(): ZodOptional<this>;
+    nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
+    nullable(): ZodNullable<this>;
+    nullish(): ZodOptional<ZodNullable<this>>;
+    default(def: output<this>): ZodDefault<this>;
+    default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
+    prefault(def: () => input<this>): ZodPrefault<this>;
+    prefault(def: input<this>): ZodPrefault<this>;
+    array(): ZodArray<this>;
+    or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
+    and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
+    transform<NewOut>(transform: (arg: output<this>, ctx: RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
+    catch(def: output<this>): ZodCatch<this>;
+    catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
+    pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
+    readonly(): ZodReadonly<this>;
+    /** 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(): $replace<GlobalMeta, this> | undefined;
+    /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+    meta(data: $replace<GlobalMeta, this>): 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;
+}
+declare const ZodType: $constructor<ZodType>;
+interface _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternals<unknown>> extends _ZodType<T> {
+    format: string | null;
+    minLength: number | null;
+    maxLength: number | null;
+    regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
+    includes(value: string, params?: $ZodCheckIncludesParams): this;
+    startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
+    endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
+    min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+    nonempty(params?: string | $ZodCheckMinLengthParams): this;
+    lowercase(params?: string | $ZodCheckLowerCaseParams): this;
+    uppercase(params?: string | $ZodCheckUpperCaseParams): this;
+    trim(): this;
+    normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+}
+/** @internal */
+declare const _ZodString: $constructor<_ZodString>;
+interface ZodString extends _ZodString<$ZodStringInternals<string>> {
+    /** @deprecated Use `z.email()` instead. */
+    email(params?: string | $ZodCheckEmailParams): this;
+    /** @deprecated Use `z.url()` instead. */
+    url(params?: string | $ZodCheckURLParams): this;
+    /** @deprecated Use `z.jwt()` instead. */
+    jwt(params?: string | $ZodCheckJWTParams): this;
+    /** @deprecated Use `z.emoji()` instead. */
+    emoji(params?: string | $ZodCheckEmojiParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | $ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuid(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv4(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv6(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv7(params?: string | $ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.nanoid()` instead. */
+    nanoid(params?: string | $ZodCheckNanoIDParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | $ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.cuid()` instead. */
+    cuid(params?: string | $ZodCheckCUIDParams): this;
+    /** @deprecated Use `z.cuid2()` instead. */
+    cuid2(params?: string | $ZodCheckCUID2Params): this;
+    /** @deprecated Use `z.ulid()` instead. */
+    ulid(params?: string | $ZodCheckULIDParams): this;
+    /** @deprecated Use `z.base64()` instead. */
+    base64(params?: string | $ZodCheckBase64Params): this;
+    /** @deprecated Use `z.base64url()` instead. */
+    base64url(params?: string | $ZodCheckBase64URLParams): this;
+    /** @deprecated Use `z.xid()` instead. */
+    xid(params?: string | $ZodCheckXIDParams): this;
+    /** @deprecated Use `z.ksuid()` instead. */
+    ksuid(params?: string | $ZodCheckKSUIDParams): this;
+    /** @deprecated Use `z.ipv4()` instead. */
+    ipv4(params?: string | $ZodCheckIPv4Params): this;
+    /** @deprecated Use `z.ipv6()` instead. */
+    ipv6(params?: string | $ZodCheckIPv6Params): this;
+    /** @deprecated Use `z.cidrv4()` instead. */
+    cidrv4(params?: string | $ZodCheckCIDRv4Params): this;
+    /** @deprecated Use `z.cidrv6()` instead. */
+    cidrv6(params?: string | $ZodCheckCIDRv6Params): this;
+    /** @deprecated Use `z.e164()` instead. */
+    e164(params?: string | $ZodCheckE164Params): this;
+    /** @deprecated Use `z.iso.datetime()` instead. */
+    datetime(params?: string | $ZodCheckISODateTimeParams): this;
+    /** @deprecated Use `z.iso.date()` instead. */
+    date(params?: string | $ZodCheckISODateParams): this;
+    /** @deprecated Use `z.iso.time()` instead. */
+    time(params?: string | $ZodCheckISOTimeParams): this;
+    /** @deprecated Use `z.iso.duration()` instead. */
+    duration(params?: string | $ZodCheckISODurationParams): this;
+}
+declare const ZodString: $constructor<ZodString>;
+interface ZodStringFormat<Format extends $ZodStringFormats = $ZodStringFormats> extends _ZodString<$ZodStringFormatInternals<Format>> {
+}
+declare const ZodStringFormat: $constructor<ZodStringFormat>;
+interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
+    element: T;
+    min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+    nonempty(params?: string | $ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+    unwrap(): T;
+}
+declare const ZodArray: $constructor<ZodArray>;
+interface ZodObject<
+/** @ts-ignore Cast variance */
+out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape, Config>>, $ZodObject<Shape, Config> {
+    shape: Shape;
+    keyof(): ZodEnum<ToEnum<keyof Shape & string>>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+    catchall<T extends SomeType>(schema: T): ZodObject<Shape, $catchall<T>>;
+    /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+    passthrough(): ZodObject<Shape, $loose>;
+    /** Consider `z.looseObject(A.shape)` instead */
+    loose(): ZodObject<Shape, $loose>;
+    /** Consider `z.strictObject(A.shape)` instead */
+    strict(): ZodObject<Shape, $strict>;
+    /** This is the default behavior. This method call is likely unnecessary. */
+    strip(): ZodObject<Shape, $strip>;
+    extend<U extends $ZodLooseShape & Partial<Record<keyof Shape, SomeType>>>(shape: U): ZodObject<Extend<Shape, U>, 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<U extends ZodObject>(other: U): ZodObject<Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
+    pick<M extends Exactly<Mask<keyof Shape>, M>>(mask: M): ZodObject<Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    omit<M extends Exactly<Mask<keyof Shape>, M>>(mask: M): ZodObject<Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    partial(): ZodObject<{
+        [k in keyof Shape]: ZodOptional<Shape[k]>;
+    }, Config>;
+    partial<M extends Exactly<Mask<keyof Shape>, M>>(mask: M): ZodObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];
+    }, Config>;
+    required(): ZodObject<{
+        [k in keyof Shape]: ZodNonOptional<Shape[k]>;
+    }, Config>;
+    required<M extends Exactly<Mask<keyof Shape>, M>>(mask: M): ZodObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];
+    }, Config>;
+}
+declare const ZodObject: $constructor<ZodObject>;
+interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+    options: T;
+}
+declare const ZodUnion: $constructor<ZodUnion>;
+interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+}
+declare const ZodIntersection: $constructor<ZodIntersection>;
+interface ZodEnum<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+    enum: T;
+    options: Array<T[keyof T]>;
+    extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
+    exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
+}
+declare const ZodEnum: $constructor<ZodEnum>;
+interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
+    values: Set<T>;
+    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+    value: T;
+}
+declare const ZodLiteral: $constructor<ZodLiteral>;
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+}
+declare const ZodTransform: $constructor<ZodTransform>;
+interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+    unwrap(): T;
+}
+declare const ZodOptional: $constructor<ZodOptional>;
+interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+    unwrap(): T;
+}
+declare const ZodNullable: $constructor<ZodNullable>;
+interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeDefault(): T;
+}
+declare const ZodDefault: $constructor<ZodDefault>;
+interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+    unwrap(): T;
+}
+declare const ZodPrefault: $constructor<ZodPrefault>;
+interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+    unwrap(): T;
+}
+declare const ZodNonOptional: $constructor<ZodNonOptional>;
+interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeCatch(): T;
+}
+declare const ZodCatch: $constructor<ZodCatch>;
+interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+    in: A;
+    out: B;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+}
+declare const ZodReadonly: $constructor<ZodReadonly>;
+
+type HttpHeaderValue = ZodString | ZodStringFormat | ZodLiteral<string> | ZodEnum<Record<string, string>>;
+type HttpHeaderSchema = ZodObject<Record<string, HttpHeaderValue | ZodOptional<HttpHeaderValue> | ZodArray<HttpHeaderValue> | ZodOptional<ZodArray<HttpHeaderValue>>>>;
+type HttpParamValue = ZodString | ZodStringFormat | ZodLiteral<string> | ZodEnum<Record<string, string>>;
+type HttpParamSchema = ZodObject<Record<string, HttpParamValue | ZodOptional<HttpParamValue>>>;
+type HttpBodySchema = ZodType;
+type HttpQueryValue = ZodString | ZodStringFormat | ZodLiteral<string> | ZodEnum<Record<string, string>>;
+type HttpQuerySchema = ZodObject<Record<string, HttpQueryValue | ZodOptional<HttpQueryValue> | ZodArray<HttpQueryValue> | ZodOptional<ZodArray<HttpQueryValue>>>>;
+
+declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    HEAD = "HEAD",
+    TRACE = "TRACE",
+    CONNECT = "CONNECT"
+}
+
+declare enum HttpStatusCode {
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    MULTI_STATUS = 207,
+    ALREADY_REPORTED = 208,
+    IM_USED = 226,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    IM_A_TEAPOT = 418,
+    MISDIRECTED_REQUEST = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    LOCKED = 423,
+    FAILED_DEPENDENCY = 424,
+    UPGRADE_REQUIRED = 426,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505,
+    VARIANT_ALSO_NEGOTIATES = 506,
+    INSUFFICIENT_STORAGE = 507,
+    LOOP_DETECTED = 508,
+    NOT_EXTENDED = 510,
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+}
+
+type IHttpRequestDefinition<THeader extends HttpHeaderSchema | undefined = HttpHeaderSchema | undefined, TParam extends HttpParamSchema | undefined = HttpParamSchema | undefined, TQuery extends HttpQuerySchema | undefined = HttpQuerySchema | undefined, TBody extends HttpBodySchema | undefined = HttpBodySchema | undefined> = {
+    header?: THeader;
+    param?: TParam;
+    query?: TQuery;
+    body?: TBody;
+};
+
+type IHttpResponseDefinition<TName extends string = string, TStatusCode extends HttpStatusCode = HttpStatusCode, TDescription extends string = string, THeader extends HttpHeaderSchema | undefined = HttpHeaderSchema | undefined, TBody extends HttpBodySchema | undefined = HttpBodySchema | undefined, TIsShared extends boolean = boolean> = {
+    name: TName;
+    statusCode: TStatusCode;
+    description: TDescription;
+    header?: THeader;
+    body?: TBody;
+    isShared?: TIsShared;
+};
+
+/**
+ * Interface for HTTP operation definitions.
+ *
+ * Represents a complete HTTP API operation with:
+ * - Unique operation identifier
+ * - HTTP method and path
+ * - Request definition (headers, params, query, body)
+ * - Response definitions for different status codes
+ *
+ * @template TOperationId - The operation identifier literal type
+ * @template TPath - The URL path literal type
+ * @template TMethod - The HTTP method type
+ * @template TSummary - The operation summary literal type
+ * @template THeader - The header schema type
+ * @template TParam - The path parameter schema type
+ * @template TQuery - The query parameter schema type
+ * @template TBody - The request body schema type
+ * @template TRequest - The complete request definition type
+ * @template TResponses - The array of response definitions
+ */
+type IHttpOperationDefinition<TOperationId extends string = string, TPath extends string = string, TMethod extends HttpMethod = HttpMethod, TSummary extends string = string, THeader extends HttpHeaderSchema | undefined = HttpHeaderSchema | undefined, TParam extends HttpParamSchema | undefined = HttpParamSchema | undefined, TQuery extends HttpQuerySchema | undefined = HttpQuerySchema | undefined, TBody extends HttpBodySchema | undefined = HttpBodySchema | undefined, TRequest extends IHttpRequestDefinition<THeader, TParam, TQuery, TBody> = IHttpRequestDefinition<THeader, TParam, TQuery, TBody>, TResponses extends IHttpResponseDefinition[] = IHttpResponseDefinition[]> = {
+    operationId: TOperationId;
+    path: TPath;
+    method: TMethod;
+    summary: TSummary;
+    request: TRequest;
+    responses: TResponses;
+};
+
+type GetResourcesResult = {
+    entityResources: EntityResources;
+    sharedResponseResources: SharedResponseResource[];
+};
+type ExtendedResponseDefinition = IHttpResponseDefinition & {
+    statusCodeName: string;
+};
+type EntityName = string;
+type OperationResource = {
+    sourceDir: string;
+    sourceFile: string;
+    sourceFileName: string;
+    definition: Omit<IHttpOperationDefinition, "responses"> & {
+        responses: ExtendedResponseDefinition[];
+    };
+    outputDir: string;
+    entityName: EntityName;
+    outputRequestFile: string;
+    outputRequestFileName: string;
+    outputResponseFile: string;
+    outputResponseFileName: string;
+    outputRequestValidationFile: string;
+    outputRequestValidationFileName: string;
+    outputResponseValidationFile: string;
+    outputResponseValidationFileName: string;
+    outputClientFile: string;
+    outputClientFileName: string;
+};
+type EntityResources = Record<EntityName, OperationResource[]>;
+type SharedResponseResource = IHttpResponseDefinition & {
+    isShared: true;
+    sourceDir: string;
+    sourceFile: string;
+    sourceFileName: string;
+    outputFile: string;
+    outputFileName: string;
+    outputDir: string;
+};
+
+/**
+ * Configuration for a TypeWeaver plugin
+ */
+type PluginConfig = Record<string, unknown>;
+/**
+ * Context provided to plugins during initialization and finalization
+ */
+interface PluginContext {
+    outputDir: string;
+    inputDir: string;
+    config: PluginConfig;
+}
+/**
+ * Context provided to plugins during generation
+ */
+interface GeneratorContext extends PluginContext {
+    resources: GetResourcesResult;
+    templateDir: string;
+    coreDir: string;
+    writeFile: (relativePath: string, content: string) => void;
+    renderTemplate: (templatePath: string, data: unknown) => string;
+    addGeneratedFile: (relativePath: string) => void;
+    getGeneratedFiles: () => string[];
+}
+/**
+ * Plugin metadata
+ */
+interface PluginMetadata {
+    name: string;
+}
+/**
+ * TypeWeaver plugin interface
+ */
+interface TypeWeaverPlugin extends PluginMetadata {
+    /**
+     * Initialize the plugin
+     * Called before any generation happens
+     */
+    initialize?(context: PluginContext): Promise<void> | void;
+    /**
+     * Collect and transform resources
+     * Allows plugins to modify the resource collection
+     */
+    collectResources?(resources: GetResourcesResult): Promise<GetResourcesResult> | GetResourcesResult;
+    /**
+     * Main generation logic
+     * Called with all resources and utilities
+     */
+    generate?(context: GeneratorContext): Promise<void> | void;
+    /**
+     * Finalize the plugin
+     * Called after all generation is complete
+     */
+    finalize?(context: PluginContext): Promise<void> | void;
+}
+
+/**
+ * Base class for TypeWeaver plugins
+ * Provides default implementations and common utilities
+ */
+declare abstract class BasePlugin implements TypeWeaverPlugin {
+    abstract name: string;
+    description?: string;
+    author?: string;
+    depends?: string[];
+    protected config: PluginConfig;
+    constructor(config?: PluginConfig);
+    /**
+     * Default implementation - override in subclasses if needed
+     */
+    initialize(context: PluginContext): Promise<void>;
+    /**
+     * Default implementation - override in subclasses if needed
+     */
+    collectResources(resources: GetResourcesResult): GetResourcesResult;
+    /**
+     * Main generation logic - must be implemented by subclasses
+     */
+    abstract generate(context: GeneratorContext): Promise<void> | void;
+    /**
+     * Default implementation - override in subclasses if needed
+     */
+    finalize(context: PluginContext): Promise<void>;
+    /**
+     * Copy lib files from plugin package to generated lib folder
+     */
+    protected copyLibFiles(context: GeneratorContext, libSourceDir: string, libNamespace: string): void;
+}
+
+declare class ClientsPlugin extends BasePlugin {
+    name: string;
+    generate(context: GeneratorContext): Promise<void> | void;
+}
+
+export { ClientsPlugin as default };