@resultdev/sdk 0.1.0 → 0.3.0

package/dist/ssr/middleware.d.ts

@@ -1,1881 +1,2 @@
-type Primitive = string | number | symbol | bigint | boolean | null | undefined;
-type Scalars = Primitive | Primitive[];
-declare namespace util {
-	type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
-	export type isAny<T> = 0 extends 1 & T ? true : false;
-	export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
-	export function assertIs<T>(_arg: T): void;
-	export function assertNever(_x: never): never;
-	export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-	export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
-	export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-	export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
-	export type InexactPartial<T> = {
-		[k in keyof T]?: T[k] | undefined;
-	};
-	export const arrayToEnum: <T extends string, U extends [
-		T,
-		...T[]
-	]>(items: U) => {
-		[k in U[number]]: k;
-	};
-	export const getValidEnumValues: (obj: any) => any[];
-	export const objectValues: (obj: any) => any[];
-	export const objectKeys: ObjectConstructor["keys"];
-	export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
-	export type identity<T> = objectUtil.identity<T>;
-	export type flatten<T> = objectUtil.flatten<T>;
-	export type noUndefined<T> = T extends undefined ? never : T;
-	export const isInteger: NumberConstructor["isInteger"];
-	export function joinValues<T extends any[]>(array: T, separator?: string): string;
-	export const jsonStringifyReplacer: (_: string, value: any) => any;
-	export {};
-}
-declare namespace objectUtil {
-	export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : {
-		[k in Exclude<keyof U, keyof V>]: U[k];
-	} & V;
-	type optionalKeys<T extends object> = {
-		[k in keyof T]: undefined extends T[k] ? k : never;
-	}[keyof T];
-	type requiredKeys<T extends object> = {
-		[k in keyof T]: undefined extends T[k] ? never : k;
-	}[keyof T];
-	export type addQuestionMarks<T extends object, _O = any> = {
-		[K in requiredKeys<T>]: T[K];
-	} & {
-		[K in optionalKeys<T>]?: T[K];
-	} & {
-		[k in keyof T]?: unknown;
-	};
-	export type identity<T> = T;
-	export type flatten<T> = identity<{
-		[k in keyof T]: T[k];
-	}>;
-	export type noNeverKeys<T> = {
-		[k in keyof T]: [
-			T[k]
-		] extends [
-			never
-		] ? never : k;
-	}[keyof T];
-	export type noNever<T> = identity<{
-		[k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
-	}>;
-	export const mergeShapes: <U, T>(first: U, second: T) => T & U;
-	export type extendShape<A extends object, B extends object> = 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];
-	};
-	export {};
-}
-declare const ZodParsedType: {
-	string: "string";
-	nan: "nan";
-	number: "number";
-	integer: "integer";
-	float: "float";
-	boolean: "boolean";
-	date: "date";
-	bigint: "bigint";
-	symbol: "symbol";
-	function: "function";
-	undefined: "undefined";
-	null: "null";
-	array: "array";
-	object: "object";
-	unknown: "unknown";
-	promise: "promise";
-	void: "void";
-	never: "never";
-	map: "map";
-	set: "set";
-};
-type ZodParsedType = keyof typeof ZodParsedType;
-declare const getParsedType: (data: any) => ZodParsedType;
-type allKeys<T> = T extends any ? keyof T : never;
-type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
-type typeToFlattenedError<T, U = string> = {
-	formErrors: U[];
-	fieldErrors: {
-		[P in allKeys<T>]?: U[];
-	};
-};
-declare const ZodIssueCode: {
-	invalid_type: "invalid_type";
-	invalid_literal: "invalid_literal";
-	custom: "custom";
-	invalid_union: "invalid_union";
-	invalid_union_discriminator: "invalid_union_discriminator";
-	invalid_enum_value: "invalid_enum_value";
-	unrecognized_keys: "unrecognized_keys";
-	invalid_arguments: "invalid_arguments";
-	invalid_return_type: "invalid_return_type";
-	invalid_date: "invalid_date";
-	invalid_string: "invalid_string";
-	too_small: "too_small";
-	too_big: "too_big";
-	invalid_intersection_types: "invalid_intersection_types";
-	not_multiple_of: "not_multiple_of";
-	not_finite: "not_finite";
-};
-type ZodIssueCode = keyof typeof ZodIssueCode;
-type ZodIssueBase = {
-	path: (string | number)[];
-	message?: string | undefined;
-};
-interface ZodInvalidTypeIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_type;
-	expected: ZodParsedType;
-	received: ZodParsedType;
-}
-interface ZodInvalidLiteralIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_literal;
-	expected: unknown;
-	received: unknown;
-}
-interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.unrecognized_keys;
-	keys: string[];
-}
-interface ZodInvalidUnionIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_union;
-	unionErrors: ZodError[];
-}
-interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_union_discriminator;
-	options: Primitive[];
-}
-interface ZodInvalidEnumValueIssue extends ZodIssueBase {
-	received: string | number;
-	code: typeof ZodIssueCode.invalid_enum_value;
-	options: (string | number)[];
-}
-interface ZodInvalidArgumentsIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_arguments;
-	argumentsError: ZodError;
-}
-interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_return_type;
-	returnTypeError: ZodError;
-}
-interface ZodInvalidDateIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_date;
-}
-type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
-	includes: string;
-	position?: number | undefined;
-} | {
-	startsWith: string;
-} | {
-	endsWith: string;
-};
-interface ZodInvalidStringIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_string;
-	validation: StringValidation;
-}
-interface ZodTooSmallIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.too_small;
-	minimum: number | bigint;
-	inclusive: boolean;
-	exact?: boolean;
-	type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodTooBigIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.too_big;
-	maximum: number | bigint;
-	inclusive: boolean;
-	exact?: boolean;
-	type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.invalid_intersection_types;
-}
-interface ZodNotMultipleOfIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.not_multiple_of;
-	multipleOf: number | bigint;
-}
-interface ZodNotFiniteIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.not_finite;
-}
-interface ZodCustomIssue extends ZodIssueBase {
-	code: typeof ZodIssueCode.custom;
-	params?: {
-		[k: string]: any;
-	};
-}
-type DenormalizedError = {
-	[k: string]: DenormalizedError | string[];
-};
-type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
-type ZodIssue = ZodIssueOptionalMessage & {
-	fatal?: boolean | undefined;
-	message: string;
-};
-declare const quotelessJson: (obj: any) => string;
-type recursiveZodFormattedError<T> = T extends [
-	any,
-	...any[]
-] ? {
-	[K in keyof T]?: ZodFormattedError<T[K]>;
-} : T extends any[] ? {
-	[k: number]: ZodFormattedError<T[number]>;
-} : T extends object ? {
-	[K in keyof T]?: ZodFormattedError<T[K]>;
-} : unknown;
-type ZodFormattedError<T, U = string> = {
-	_errors: U[];
-} & recursiveZodFormattedError<NonNullable<T>>;
-type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
-declare class ZodError<T = any> extends Error {
-	issues: ZodIssue[];
-	get errors(): ZodIssue[];
-	constructor(issues: ZodIssue[]);
-	format(): ZodFormattedError<T>;
-	format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
-	static create: (issues: ZodIssue[]) => ZodError<any>;
-	static assert(value: unknown): asserts value is ZodError;
-	toString(): string;
-	get message(): string;
-	get isEmpty(): boolean;
-	addIssue: (sub: ZodIssue) => void;
-	addIssues: (subs?: ZodIssue[]) => void;
-	flatten(): typeToFlattenedError<T>;
-	flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
-	get formErrors(): typeToFlattenedError<T, string>;
-}
-type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-type IssueData = stripPath<ZodIssueOptionalMessage> & {
-	path?: (string | number)[];
-	fatal?: boolean | undefined;
-};
-type ErrorMapCtx = {
-	defaultError: string;
-	data: any;
-};
-type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
-	message: string;
-};
-declare const errorMap: ZodErrorMap;
-declare function setErrorMap(map: ZodErrorMap): void;
-declare function getErrorMap(): ZodErrorMap;
-declare const makeIssue: (params: {
-	data: any;
-	path: (string | number)[];
-	errorMaps: ZodErrorMap[];
-	issueData: IssueData;
-}) => ZodIssue;
-type ParseParams = {
-	path: (string | number)[];
-	errorMap: ZodErrorMap;
-	async: boolean;
-};
-type ParsePathComponent = string | number;
-type ParsePath = ParsePathComponent[];
-declare const EMPTY_PATH: ParsePath;
-interface ParseContext {
-	readonly common: {
-		readonly issues: ZodIssue[];
-		readonly contextualErrorMap?: ZodErrorMap | undefined;
-		readonly async: boolean;
-	};
-	readonly path: ParsePath;
-	readonly schemaErrorMap?: ZodErrorMap | undefined;
-	readonly parent: ParseContext | null;
-	readonly data: any;
-	readonly parsedType: ZodParsedType;
-}
-type ParseInput = {
-	data: any;
-	path: (string | number)[];
-	parent: ParseContext;
-};
-declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
-type ObjectPair = {
-	key: SyncParseReturnType<any>;
-	value: SyncParseReturnType<any>;
-};
-declare class ParseStatus {
-	value: "aborted" | "dirty" | "valid";
-	dirty(): void;
-	abort(): void;
-	static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
-	static mergeObjectAsync(status: ParseStatus, pairs: {
-		key: ParseReturnType<any>;
-		value: ParseReturnType<any>;
-	}[]): Promise<SyncParseReturnType<any>>;
-	static mergeObjectSync(status: ParseStatus, pairs: {
-		key: SyncParseReturnType<any>;
-		value: SyncParseReturnType<any>;
-		alwaysSet?: boolean;
-	}[]): SyncParseReturnType;
-}
-interface ParseResult {
-	status: "aborted" | "dirty" | "valid";
-	data: any;
-}
-type INVALID = {
-	status: "aborted";
-};
-declare const INVALID: INVALID;
-type DIRTY<T> = {
-	status: "dirty";
-	value: T;
-};
-declare const DIRTY: <T>(value: T) => DIRTY<T>;
-type OK<T> = {
-	status: "valid";
-	value: T;
-};
-declare const OK: <T>(value: T) => OK<T>;
-type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
-declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
-declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
-declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
-declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
-declare namespace enumUtil {
-	type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
-	type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
-	type UnionToTuple<T, Tuple extends unknown[] = [
-	]> = [
-		T
-	] extends [
-		never
-	] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [
-		GetUnionLast<T>,
-		...Tuple
-	]>;
-	type CastToStringTuple<T> = T extends [
-		string,
-		...string[]
-	] ? T : never;
-	export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
-	export {};
-}
-declare namespace errorUtil {
-	type ErrMessage = string | {
-		message?: string | undefined;
-	};
-	const errToObj: (message?: ErrMessage) => {
-		message?: string | undefined;
-	};
-	const toString: (message?: ErrMessage) => string | undefined;
-}
-declare namespace partialUtil {
-	type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
-		[k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;
-	}, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
-		[k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
-	} extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
-}
-type StandardSchemaV1<Input = unknown, Output = Input> = {
-	/**
-	 * The Standard Schema properties.
-	 */
-	readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-};
-declare namespace StandardSchemaV1 {
-	/**
-	 * The Standard Schema properties interface.
-	 */
-	export 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.
-	 */
-	export type Result<Output> = SuccessResult<Output> | FailureResult;
-	/**
-	 * The result interface if validation succeeds.
-	 */
-	export interface SuccessResult<Output> {
-		/**
-		 * The typed output value.
-		 */
-		readonly value: Output;
-		/**
-		 * The non-existent issues.
-		 */
-		readonly issues?: undefined;
-	}
-	/**
-	 * The result interface if validation fails.
-	 */
-	export interface FailureResult {
-		/**
-		 * The issues of failed validation.
-		 */
-		readonly issues: ReadonlyArray<Issue>;
-	}
-	/**
-	 * The issue interface of the failure output.
-	 */
-	export 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.
-	 */
-	export interface PathSegment {
-		/**
-		 * The key representing a path segment.
-		 */
-		readonly key: PropertyKey;
-	}
-	/**
-	 * The Standard Schema types interface.
-	 */
-	export 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.
-	 */
-	export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-	/**
-	 * Infers the output type of a Standard Schema.
-	 */
-	export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-	export {};
-}
-interface RefinementCtx {
-	addIssue: (arg: IssueData) => void;
-	path: (string | number)[];
-}
-type ZodRawShape = {
-	[k: string]: ZodTypeAny;
-};
-type ZodTypeAny = ZodType<any, any, any>;
-type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-type input<T extends ZodType<any, any, any>> = T["_input"];
-type output<T extends ZodType<any, any, any>> = T["_output"];
-type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
-interface ZodTypeDef {
-	errorMap?: ZodErrorMap | undefined;
-	description?: string | undefined;
-}
-type RawCreateParams = {
-	errorMap?: ZodErrorMap | undefined;
-	invalid_type_error?: string | undefined;
-	required_error?: string | undefined;
-	message?: string | undefined;
-	description?: string | undefined;
-} | undefined;
-type ProcessedCreateParams = {
-	errorMap?: ZodErrorMap | undefined;
-	description?: string | undefined;
-};
-type SafeParseSuccess<Output> = {
-	success: true;
-	data: Output;
-	error?: never;
-};
-type SafeParseError<Input> = {
-	success: false;
-	error: ZodError<Input>;
-	data?: never;
-};
-type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
-	readonly _type: Output;
-	readonly _output: Output;
-	readonly _input: Input;
-	readonly _def: Def;
-	get description(): string | undefined;
-	"~standard": StandardSchemaV1.Props<Input, Output>;
-	abstract _parse(input: ParseInput): ParseReturnType<Output>;
-	_getType(input: ParseInput): string;
-	_getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
-	_processInputParams(input: ParseInput): {
-		status: ParseStatus;
-		ctx: ParseContext;
-	};
-	_parseSync(input: ParseInput): SyncParseReturnType<Output>;
-	_parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-	parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
-	safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
-	"~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-	parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
-	safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
-	/** Alias of safeParseAsync */
-	spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
-	refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
-	refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
-	refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
-	refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
-	_refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
-	superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
-	superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
-	superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
-	constructor(def: Def);
-	optional(): ZodOptional<this>;
-	nullable(): ZodNullable<this>;
-	nullish(): ZodOptional<ZodNullable<this>>;
-	array(): ZodArray<this>;
-	promise(): ZodPromise<this>;
-	or<T extends ZodTypeAny>(option: T): ZodUnion<[
-		this,
-		T
-	]>;
-	and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
-	transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
-	default(def: util.noUndefined<Input>): ZodDefault<this>;
-	default(def: () => util.noUndefined<Input>): ZodDefault<this>;
-	brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
-	catch(def: Output): ZodCatch<this>;
-	catch(def: (ctx: {
-		error: ZodError;
-		input: Input;
-	}) => Output): ZodCatch<this>;
-	describe(description: string): this;
-	pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
-	readonly(): ZodReadonly<this>;
-	isOptional(): boolean;
-	isNullable(): boolean;
-}
-type IpVersion = "v4" | "v6";
-type ZodStringCheck = {
-	kind: "min";
-	value: number;
-	message?: string | undefined;
-} | {
-	kind: "max";
-	value: number;
-	message?: string | undefined;
-} | {
-	kind: "length";
-	value: number;
-	message?: string | undefined;
-} | {
-	kind: "email";
-	message?: string | undefined;
-} | {
-	kind: "url";
-	message?: string | undefined;
-} | {
-	kind: "emoji";
-	message?: string | undefined;
-} | {
-	kind: "uuid";
-	message?: string | undefined;
-} | {
-	kind: "nanoid";
-	message?: string | undefined;
-} | {
-	kind: "cuid";
-	message?: string | undefined;
-} | {
-	kind: "includes";
-	value: string;
-	position?: number | undefined;
-	message?: string | undefined;
-} | {
-	kind: "cuid2";
-	message?: string | undefined;
-} | {
-	kind: "ulid";
-	message?: string | undefined;
-} | {
-	kind: "startsWith";
-	value: string;
-	message?: string | undefined;
-} | {
-	kind: "endsWith";
-	value: string;
-	message?: string | undefined;
-} | {
-	kind: "regex";
-	regex: RegExp;
-	message?: string | undefined;
-} | {
-	kind: "trim";
-	message?: string | undefined;
-} | {
-	kind: "toLowerCase";
-	message?: string | undefined;
-} | {
-	kind: "toUpperCase";
-	message?: string | undefined;
-} | {
-	kind: "jwt";
-	alg?: string;
-	message?: string | undefined;
-} | {
-	kind: "datetime";
-	offset: boolean;
-	local: boolean;
-	precision: number | null;
-	message?: string | undefined;
-} | {
-	kind: "date";
-	message?: string | undefined;
-} | {
-	kind: "time";
-	precision: number | null;
-	message?: string | undefined;
-} | {
-	kind: "duration";
-	message?: string | undefined;
-} | {
-	kind: "ip";
-	version?: IpVersion | undefined;
-	message?: string | undefined;
-} | {
-	kind: "cidr";
-	version?: IpVersion | undefined;
-	message?: string | undefined;
-} | {
-	kind: "base64";
-	message?: string | undefined;
-} | {
-	kind: "base64url";
-	message?: string | undefined;
-};
-interface ZodStringDef extends ZodTypeDef {
-	checks: ZodStringCheck[];
-	typeName: ZodFirstPartyTypeKind.ZodString;
-	coerce: boolean;
-}
-declare function datetimeRegex(args: {
-	precision?: number | null;
-	offset?: boolean;
-	local?: boolean;
-}): RegExp;
-declare class ZodString extends ZodType<string, ZodStringDef, string> {
-	_parse(input: ParseInput): ParseReturnType<string>;
-	protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
-	_addCheck(check: ZodStringCheck): ZodString;
-	email(message?: errorUtil.ErrMessage): ZodString;
-	url(message?: errorUtil.ErrMessage): ZodString;
-	emoji(message?: errorUtil.ErrMessage): ZodString;
-	uuid(message?: errorUtil.ErrMessage): ZodString;
-	nanoid(message?: errorUtil.ErrMessage): ZodString;
-	cuid(message?: errorUtil.ErrMessage): ZodString;
-	cuid2(message?: errorUtil.ErrMessage): ZodString;
-	ulid(message?: errorUtil.ErrMessage): ZodString;
-	base64(message?: errorUtil.ErrMessage): ZodString;
-	base64url(message?: errorUtil.ErrMessage): ZodString;
-	jwt(options?: {
-		alg?: string;
-		message?: string | undefined;
-	}): ZodString;
-	ip(options?: string | {
-		version?: IpVersion;
-		message?: string | undefined;
-	}): ZodString;
-	cidr(options?: string | {
-		version?: IpVersion;
-		message?: string | undefined;
-	}): ZodString;
-	datetime(options?: string | {
-		message?: string | undefined;
-		precision?: number | null;
-		offset?: boolean;
-		local?: boolean;
-	}): ZodString;
-	date(message?: string): ZodString;
-	time(options?: string | {
-		message?: string | undefined;
-		precision?: number | null;
-	}): ZodString;
-	duration(message?: errorUtil.ErrMessage): ZodString;
-	regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
-	includes(value: string, options?: {
-		message?: string;
-		position?: number;
-	}): ZodString;
-	startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
-	endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
-	min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
-	max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
-	length(len: number, message?: errorUtil.ErrMessage): ZodString;
-	/**
-	 * Equivalent to `.min(1)`
-	 */
-	nonempty(message?: errorUtil.ErrMessage): ZodString;
-	trim(): ZodString;
-	toLowerCase(): ZodString;
-	toUpperCase(): ZodString;
-	get isDatetime(): boolean;
-	get isDate(): boolean;
-	get isTime(): boolean;
-	get isDuration(): boolean;
-	get isEmail(): boolean;
-	get isURL(): boolean;
-	get isEmoji(): boolean;
-	get isUUID(): boolean;
-	get isNANOID(): boolean;
-	get isCUID(): boolean;
-	get isCUID2(): boolean;
-	get isULID(): boolean;
-	get isIP(): boolean;
-	get isCIDR(): boolean;
-	get isBase64(): boolean;
-	get isBase64url(): boolean;
-	get minLength(): number | null;
-	get maxLength(): number | null;
-	static create: (params?: RawCreateParams & {
-		coerce?: true;
-	}) => ZodString;
-}
-type ZodNumberCheck = {
-	kind: "min";
-	value: number;
-	inclusive: boolean;
-	message?: string | undefined;
-} | {
-	kind: "max";
-	value: number;
-	inclusive: boolean;
-	message?: string | undefined;
-} | {
-	kind: "int";
-	message?: string | undefined;
-} | {
-	kind: "multipleOf";
-	value: number;
-	message?: string | undefined;
-} | {
-	kind: "finite";
-	message?: string | undefined;
-};
-interface ZodNumberDef extends ZodTypeDef {
-	checks: ZodNumberCheck[];
-	typeName: ZodFirstPartyTypeKind.ZodNumber;
-	coerce: boolean;
-}
-declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
-	_parse(input: ParseInput): ParseReturnType<number>;
-	static create: (params?: RawCreateParams & {
-		coerce?: boolean;
-	}) => ZodNumber;
-	gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-	min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-	gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-	lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-	max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-	lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-	protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
-	_addCheck(check: ZodNumberCheck): ZodNumber;
-	int(message?: errorUtil.ErrMessage): ZodNumber;
-	positive(message?: errorUtil.ErrMessage): ZodNumber;
-	negative(message?: errorUtil.ErrMessage): ZodNumber;
-	nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
-	nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
-	multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-	step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-	finite(message?: errorUtil.ErrMessage): ZodNumber;
-	safe(message?: errorUtil.ErrMessage): ZodNumber;
-	get minValue(): number | null;
-	get maxValue(): number | null;
-	get isInt(): boolean;
-	get isFinite(): boolean;
-}
-type ZodBigIntCheck = {
-	kind: "min";
-	value: bigint;
-	inclusive: boolean;
-	message?: string | undefined;
-} | {
-	kind: "max";
-	value: bigint;
-	inclusive: boolean;
-	message?: string | undefined;
-} | {
-	kind: "multipleOf";
-	value: bigint;
-	message?: string | undefined;
-};
-interface ZodBigIntDef extends ZodTypeDef {
-	checks: ZodBigIntCheck[];
-	typeName: ZodFirstPartyTypeKind.ZodBigInt;
-	coerce: boolean;
-}
-declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
-	_parse(input: ParseInput): ParseReturnType<bigint>;
-	_getInvalidInput(input: ParseInput): INVALID;
-	static create: (params?: RawCreateParams & {
-		coerce?: boolean;
-	}) => ZodBigInt;
-	gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-	min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
-	gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-	lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-	max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
-	lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-	protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
-	_addCheck(check: ZodBigIntCheck): ZodBigInt;
-	positive(message?: errorUtil.ErrMessage): ZodBigInt;
-	negative(message?: errorUtil.ErrMessage): ZodBigInt;
-	nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;
-	nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;
-	multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-	get minValue(): bigint | null;
-	get maxValue(): bigint | null;
-}
-interface ZodBooleanDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodBoolean;
-	coerce: boolean;
-}
-declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
-	_parse(input: ParseInput): ParseReturnType<boolean>;
-	static create: (params?: RawCreateParams & {
-		coerce?: boolean;
-	}) => ZodBoolean;
-}
-type ZodDateCheck = {
-	kind: "min";
-	value: number;
-	message?: string | undefined;
-} | {
-	kind: "max";
-	value: number;
-	message?: string | undefined;
-};
-interface ZodDateDef extends ZodTypeDef {
-	checks: ZodDateCheck[];
-	coerce: boolean;
-	typeName: ZodFirstPartyTypeKind.ZodDate;
-}
-declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	_addCheck(check: ZodDateCheck): ZodDate;
-	min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
-	max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
-	get minDate(): Date | null;
-	get maxDate(): Date | null;
-	static create: (params?: RawCreateParams & {
-		coerce?: boolean;
-	}) => ZodDate;
-}
-interface ZodSymbolDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodSymbol;
-}
-declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: (params?: RawCreateParams) => ZodSymbol;
-}
-interface ZodUndefinedDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodUndefined;
-}
-declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	params?: RawCreateParams;
-	static create: (params?: RawCreateParams) => ZodUndefined;
-}
-interface ZodNullDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodNull;
-}
-declare class ZodNull extends ZodType<null, ZodNullDef, null> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: (params?: RawCreateParams) => ZodNull;
-}
-interface ZodAnyDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodAny;
-}
-declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
-	_any: true;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: (params?: RawCreateParams) => ZodAny;
-}
-interface ZodUnknownDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodUnknown;
-}
-declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
-	_unknown: true;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: (params?: RawCreateParams) => ZodUnknown;
-}
-interface ZodNeverDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodNever;
-}
-declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: (params?: RawCreateParams) => ZodNever;
-}
-interface ZodVoidDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodVoid;
-}
-declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: (params?: RawCreateParams) => ZodVoid;
-}
-interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	type: T;
-	typeName: ZodFirstPartyTypeKind.ZodArray;
-	exactLength: {
-		value: number;
-		message?: string | undefined;
-	} | null;
-	minLength: {
-		value: number;
-		message?: string | undefined;
-	} | null;
-	maxLength: {
-		value: number;
-		message?: string | undefined;
-	} | null;
-}
-type ArrayCardinality = "many" | "atleastone";
-type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [
-	T["_output"],
-	...T["_output"][]
-] : T["_output"][];
-declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [
-	T["_input"],
-	...T["_input"][]
-] : T["_input"][]> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get element(): T;
-	min(minLength: number, message?: errorUtil.ErrMessage): this;
-	max(maxLength: number, message?: errorUtil.ErrMessage): this;
-	length(len: number, message?: errorUtil.ErrMessage): this;
-	nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-	static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
-}
-type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
-type UnknownKeysParam = "passthrough" | "strict" | "strip";
-interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodObject;
-	shape: () => T;
-	catchall: Catchall;
-	unknownKeys: UnknownKeys;
-}
-type mergeTypes<A, B> = {
-	[k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
-};
-type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectOutputType<Shape extends ZodRawShape> = {
-	[k in keyof Shape]: Shape[k]["_output"];
-};
-type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
-	[k in keyof Shape]: Shape[k]["_input"];
-}>;
-type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
-	[k: string]: T["_output"];
-};
-type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
-	[k: string]: T["_input"];
-};
-type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
-	[k: string]: unknown;
-} : unknown;
-type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
-type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-type noUnrecognized<Obj extends object, Shape extends object> = {
-	[k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
-};
-declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
-	private _cached;
-	_getCached(): {
-		shape: T;
-		keys: string[];
-	};
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get shape(): T;
-	strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
-	strip(): ZodObject<T, "strip", Catchall>;
-	passthrough(): ZodObject<T, "passthrough", Catchall>;
-	/**
-	 * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
-	 * If you want to pass through unknown properties, use `.passthrough()` instead.
-	 */
-	nonstrict: () => ZodObject<T, "passthrough", Catchall>;
-	extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-	/**
-	 * @deprecated Use `.extend` instead
-	 *  */
-	augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-	/**
-	 * Prior to zod@1.0.12 there was a bug in the
-	 * inferred type of merged objects. Please
-	 * upgrade if you are experiencing issues.
-	 */
-	merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
-	setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {
-		[k in Key]: Schema;
-	}, UnknownKeys, Catchall>;
-	catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-	pick<Mask extends util.Exactly<{
-		[k in keyof T]?: true;
-	}, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-	omit<Mask extends util.Exactly<{
-		[k in keyof T]?: true;
-	}, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
-	/**
-	 * @deprecated
-	 */
-	deepPartial(): partialUtil.DeepPartial<this>;
-	partial(): ZodObject<{
-		[k in keyof T]: ZodOptional<T[k]>;
-	}, UnknownKeys, Catchall>;
-	partial<Mask extends util.Exactly<{
-		[k in keyof T]?: true;
-	}, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
-		[k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
-	}>, UnknownKeys, Catchall>;
-	required(): ZodObject<{
-		[k in keyof T]: deoptional<T[k]>;
-	}, UnknownKeys, Catchall>;
-	required<Mask extends util.Exactly<{
-		[k in keyof T]?: true;
-	}, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
-		[k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
-	}>, UnknownKeys, Catchall>;
-	keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-	static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
-	static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
-	static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
-}
-type AnyZodObject = ZodObject<any, any, any>;
-type ZodUnionOptions = Readonly<[
-	ZodTypeAny,
-	...ZodTypeAny[]
-]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
-	ZodTypeAny,
-	ZodTypeAny,
-	...ZodTypeAny[]
-]>> extends ZodTypeDef {
-	options: T;
-	typeName: ZodFirstPartyTypeKind.ZodUnion;
-}
-declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get options(): T;
-	static create: <Options extends Readonly<[
-		ZodTypeAny,
-		ZodTypeAny,
-		...ZodTypeAny[]
-	]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
-}
-type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
-	[key in Discriminator]: ZodTypeAny;
-} & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
-	discriminator: Discriminator;
-	options: Options;
-	optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
-	typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
-}
-declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get discriminator(): Discriminator;
-	get options(): Options;
-	get optionsMap(): Map<Primitive, ZodDiscriminatedUnionOption<any>>;
-	/**
-	 * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
-	 * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
-	 * have a different value for each object in the union.
-	 * @param discriminator the name of the discriminator property
-	 * @param types an array of object schemas
-	 * @param params
-	 */
-	static create<Discriminator extends string, Types extends readonly [
-		ZodDiscriminatedUnionOption<Discriminator>,
-		...ZodDiscriminatedUnionOption<Discriminator>[]
-	]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
-}
-interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	left: T;
-	right: U;
-	typeName: ZodFirstPartyTypeKind.ZodIntersection;
-}
-declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
-}
-type ZodTupleItems = [
-	ZodTypeAny,
-	...ZodTypeAny[]
-];
-type AssertArray<T> = T extends any[] ? T : never;
-type OutputTypeOfTuple<T extends ZodTupleItems | [
-]> = AssertArray<{
-	[k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
-}>;
-type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [
-], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [
-	...OutputTypeOfTuple<T>,
-	...Rest["_output"][]
-] : OutputTypeOfTuple<T>;
-type InputTypeOfTuple<T extends ZodTupleItems | [
-]> = AssertArray<{
-	[k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
-}>;
-type InputTypeOfTupleWithRest<T extends ZodTupleItems | [
-], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [
-	...InputTypeOfTuple<T>,
-	...Rest["_input"][]
-] : InputTypeOfTuple<T>;
-interface ZodTupleDef<T extends ZodTupleItems | [
-] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
-	items: T;
-	rest: Rest;
-	typeName: ZodFirstPartyTypeKind.ZodTuple;
-}
-type AnyZodTuple = ZodTuple<[
-	ZodTypeAny,
-	...ZodTypeAny[]
-] | [
-], ZodTypeAny | null>;
-declare class ZodTuple<T extends ZodTupleItems | [
-] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get items(): T;
-	rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
-	static create: <Items extends [
-		ZodTypeAny,
-		...ZodTypeAny[]
-	] | [
-	]>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
-}
-interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	valueType: Value;
-	keyType: Key;
-	typeName: ZodFirstPartyTypeKind.ZodRecord;
-}
-type KeySchema = ZodType<string | number | symbol, any, any>;
-type RecordType<K extends string | number | symbol, V> = [
-	string
-] extends [
-	K
-] ? Record<K, V> : [
-	number
-] extends [
-	K
-] ? Record<K, V> : [
-	symbol
-] extends [
-	K
-] ? Record<K, V> : [
-	BRAND<string | number | symbol>
-] extends [
-	K
-] ? Record<K, V> : Partial<Record<K, V>>;
-declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
-	get keySchema(): Key;
-	get valueSchema(): Value;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get element(): Value;
-	static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
-	static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
-}
-interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	valueType: Value;
-	keyType: Key;
-	typeName: ZodFirstPartyTypeKind.ZodMap;
-}
-declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
-	get keySchema(): Key;
-	get valueSchema(): Value;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
-}
-interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	valueType: Value;
-	typeName: ZodFirstPartyTypeKind.ZodSet;
-	minSize: {
-		value: number;
-		message?: string | undefined;
-	} | null;
-	maxSize: {
-		value: number;
-		message?: string | undefined;
-	} | null;
-}
-declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	min(minSize: number, message?: errorUtil.ErrMessage): this;
-	max(maxSize: number, message?: errorUtil.ErrMessage): this;
-	size(size: number, message?: errorUtil.ErrMessage): this;
-	nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
-	static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
-}
-interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	args: Args;
-	returns: Returns;
-	typeName: ZodFirstPartyTypeKind.ZodFunction;
-}
-type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
-type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
-declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
-	_parse(input: ParseInput): ParseReturnType<any>;
-	parameters(): Args;
-	returnType(): Returns;
-	args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
-	returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
-	implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
-	strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
-	validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
-	static create(): ZodFunction<ZodTuple<[
-	], ZodUnknown>, ZodUnknown>;
-	static create<T extends AnyZodTuple = ZodTuple<[
-	], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
-	static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
-	static create<T extends AnyZodTuple = ZodTuple<[
-	], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
-}
-interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	getter: () => T;
-	typeName: ZodFirstPartyTypeKind.ZodLazy;
-}
-declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
-	get schema(): T;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
-}
-interface ZodLiteralDef<T = any> extends ZodTypeDef {
-	value: T;
-	typeName: ZodFirstPartyTypeKind.ZodLiteral;
-}
-declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get value(): T;
-	static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
-}
-type ArrayKeys = keyof any[];
-type Indices<T> = Exclude<keyof T, ArrayKeys>;
-type EnumValues<T extends string = string> = readonly [
-	T,
-	...T[]
-];
-type Values<T extends EnumValues> = {
-	[k in T[number]]: k;
-};
-interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
-	values: T;
-	typeName: ZodFirstPartyTypeKind.ZodEnum;
-}
-type Writeable<T> = {
-	-readonly [P in keyof T]: T[P];
-};
-type FilterEnum<Values, ToExclude> = Values extends [
-] ? [
-] : Values extends [
-	infer Head,
-	...infer Rest
-] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [
-	Head,
-	...FilterEnum<Rest, ToExclude>
-] : never;
-type typecast<A, T> = A extends T ? A : never;
-declare function createZodEnum<U extends string, T extends Readonly<[
-	U,
-	...U[]
-]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
-declare function createZodEnum<U extends string, T extends [
-	U,
-	...U[]
-]>(values: T, params?: RawCreateParams): ZodEnum<T>;
-declare class ZodEnum<T extends [
-	string,
-	...string[]
-]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-	_cache: Set<T[number]> | undefined;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	get options(): T;
-	get enum(): Values<T>;
-	get Values(): Values<T>;
-	get Enum(): Values<T>;
-	extract<ToExtract extends readonly [
-		T[number],
-		...T[number][]
-	]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
-	exclude<ToExclude extends readonly [
-		T[number],
-		...T[number][]
-	]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [
-		string,
-		...string[]
-	]>>;
-	static create: typeof createZodEnum;
-}
-interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
-	values: T;
-	typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
-}
-type EnumLike = {
-	[k: string]: string | number;
-	[nu: number]: string;
-};
-declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
-	_cache: Set<T[keyof T]> | undefined;
-	_parse(input: ParseInput): ParseReturnType<T[keyof T]>;
-	get enum(): T;
-	static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
-}
-interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	type: T;
-	typeName: ZodFirstPartyTypeKind.ZodPromise;
-}
-declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
-	unwrap(): T;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
-}
-type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
-type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
-type RefinementEffect<T> = {
-	type: "refinement";
-	refinement: (arg: T, ctx: RefinementCtx) => any;
-};
-type TransformEffect<T> = {
-	type: "transform";
-	transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type PreprocessEffect<T> = {
-	type: "preprocess";
-	transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
-interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	schema: T;
-	typeName: ZodFirstPartyTypeKind.ZodEffects;
-	effect: Effect<any>;
-}
-declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
-	innerType(): T;
-	sourceType(): T;
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-	static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-}
-interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	innerType: T;
-	typeName: ZodFirstPartyTypeKind.ZodOptional;
-}
-type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
-declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	unwrap(): T;
-	static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
-}
-interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	innerType: T;
-	typeName: ZodFirstPartyTypeKind.ZodNullable;
-}
-type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
-declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	unwrap(): T;
-	static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
-}
-interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	innerType: T;
-	defaultValue: () => util.noUndefined<T["_input"]>;
-	typeName: ZodFirstPartyTypeKind.ZodDefault;
-}
-declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	removeDefault(): T;
-	static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-		default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
-	}) => ZodDefault<Inner>;
-}
-interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	innerType: T;
-	catchValue: (ctx: {
-		error: ZodError;
-		input: unknown;
-	}) => T["_input"];
-	typeName: ZodFirstPartyTypeKind.ZodCatch;
-}
-declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	removeCatch(): T;
-	static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-		catch: Inner["_output"] | (() => Inner["_output"]);
-	}) => ZodCatch<Inner>;
-}
-interface ZodNaNDef extends ZodTypeDef {
-	typeName: ZodFirstPartyTypeKind.ZodNaN;
-}
-declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
-	_parse(input: ParseInput): ParseReturnType<any>;
-	static create: (params?: RawCreateParams) => ZodNaN;
-}
-interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
-	type: T;
-	typeName: ZodFirstPartyTypeKind.ZodBranded;
-}
-declare const BRAND: unique symbol;
-type BRAND<T extends string | number | symbol> = {
-	[BRAND]: {
-		[k in T]: true;
-	};
-};
-declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
-	_parse(input: ParseInput): ParseReturnType<any>;
-	unwrap(): T;
-}
-interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
-	in: A;
-	out: B;
-	typeName: ZodFirstPartyTypeKind.ZodPipeline;
-}
-declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
-	_parse(input: ParseInput): ParseReturnType<any>;
-	static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
-}
-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>;
-interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-	innerType: T;
-	typeName: ZodFirstPartyTypeKind.ZodReadonly;
-}
-declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
-	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
-	static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
-	unwrap(): T;
-}
-type CustomParams = CustomErrorParams & {
-	fatal?: boolean;
-};
-declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams), 
-/**
- * @deprecated
- *
- * Pass `fatal` into the params object instead:
- *
- * ```ts
- * z.string().custom((val) => val.length > 5, { fatal: false })
- * ```
- *
- */
-fatal?: boolean): ZodType<T, ZodTypeDef, T>;
-declare const late: {
-	object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
-};
-declare enum ZodFirstPartyTypeKind {
-	ZodString = "ZodString",
-	ZodNumber = "ZodNumber",
-	ZodNaN = "ZodNaN",
-	ZodBigInt = "ZodBigInt",
-	ZodBoolean = "ZodBoolean",
-	ZodDate = "ZodDate",
-	ZodSymbol = "ZodSymbol",
-	ZodUndefined = "ZodUndefined",
-	ZodNull = "ZodNull",
-	ZodAny = "ZodAny",
-	ZodUnknown = "ZodUnknown",
-	ZodNever = "ZodNever",
-	ZodVoid = "ZodVoid",
-	ZodArray = "ZodArray",
-	ZodObject = "ZodObject",
-	ZodUnion = "ZodUnion",
-	ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
-	ZodIntersection = "ZodIntersection",
-	ZodTuple = "ZodTuple",
-	ZodRecord = "ZodRecord",
-	ZodMap = "ZodMap",
-	ZodSet = "ZodSet",
-	ZodFunction = "ZodFunction",
-	ZodLazy = "ZodLazy",
-	ZodLiteral = "ZodLiteral",
-	ZodEnum = "ZodEnum",
-	ZodEffects = "ZodEffects",
-	ZodNativeEnum = "ZodNativeEnum",
-	ZodOptional = "ZodOptional",
-	ZodNullable = "ZodNullable",
-	ZodDefault = "ZodDefault",
-	ZodCatch = "ZodCatch",
-	ZodPromise = "ZodPromise",
-	ZodBranded = "ZodBranded",
-	ZodPipeline = "ZodPipeline",
-	ZodReadonly = "ZodReadonly"
-}
-type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
-declare abstract class Class {
-	constructor(..._: any[]);
-}
-declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
-declare const stringType: (params?: RawCreateParams & {
-	coerce?: true;
-}) => ZodString;
-declare const numberType: (params?: RawCreateParams & {
-	coerce?: boolean;
-}) => ZodNumber;
-declare const nanType: (params?: RawCreateParams) => ZodNaN;
-declare const bigIntType: (params?: RawCreateParams & {
-	coerce?: boolean;
-}) => ZodBigInt;
-declare const booleanType: (params?: RawCreateParams & {
-	coerce?: boolean;
-}) => ZodBoolean;
-declare const dateType: (params?: RawCreateParams & {
-	coerce?: boolean;
-}) => ZodDate;
-declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
-declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
-declare const nullType: (params?: RawCreateParams) => ZodNull;
-declare const anyType: (params?: RawCreateParams) => ZodAny;
-declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
-declare const neverType: (params?: RawCreateParams) => ZodNever;
-declare const voidType: (params?: RawCreateParams) => ZodVoid;
-declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
-declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
-declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
-declare const unionType: <Options extends Readonly<[
-	ZodTypeAny,
-	ZodTypeAny,
-	...ZodTypeAny[]
-]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
-declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
-declare const intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
-declare const tupleType: <Items extends [
-	ZodTypeAny,
-	...ZodTypeAny[]
-] | [
-]>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
-declare const recordType: typeof ZodRecord.create;
-declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
-declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
-declare const functionType: typeof ZodFunction.create;
-declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
-declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
-declare const enumType: typeof createZodEnum;
-declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
-declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
-declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
-declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
-declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-declare const pipelineType: typeof ZodPipeline.create;
-declare const ostring: () => ZodOptional<ZodString>;
-declare const onumber: () => ZodOptional<ZodNumber>;
-declare const oboolean: () => ZodOptional<ZodBoolean>;
-declare const coerce: {
-	string: (typeof ZodString)["create"];
-	number: (typeof ZodNumber)["create"];
-	boolean: (typeof ZodBoolean)["create"];
-	bigint: (typeof ZodBigInt)["create"];
-	date: (typeof ZodDate)["create"];
-};
-declare const NEVER: never;
-declare const errorCodeSchema: z.ZodEnum<[
-	"AUTH_INVALID_EMAIL",
-	"AUTH_WEAK_PASSWORD",
-	"AUTH_INVALID_CREDENTIALS",
-	"AUTH_INVALID_API_KEY",
-	"AUTH_EMAIL_EXISTS",
-	"AUTH_USER_NOT_FOUND",
-	"AUTH_OAUTH_CONFIG_ALREADY_EXISTS",
-	"AUTH_OAUTH_CONFIG_ERROR",
-	"AUTH_OAUTH_CONFIG_NOT_FOUND",
-	"AUTH_UNSUPPORTED_PROVIDER",
-	"AUTH_TOKEN_EXPIRED",
-	"AUTH_UNAUTHORIZED",
-	"AUTH_NEED_VERIFICATION",
-	"AUTH_SIGNUP_DISABLED",
-	"DATABASE_INVALID_PARAMETER",
-	"DATABASE_VALIDATION_ERROR",
-	"DATABASE_CONSTRAINT_VIOLATION",
-	"DATABASE_NOT_FOUND",
-	"DATABASE_DUPLICATE",
-	"DATABASE_MIGRATION_ALREADY_EXISTS",
-	"DATABASE_PERMISSION_DENIED",
-	"DATABASE_INTERNAL_ERROR",
-	"DATABASE_FORBIDDEN",
-	"STORAGE_ALREADY_EXISTS",
-	"STORAGE_INVALID_PARAMETER",
-	"STORAGE_INVALID_FILE_TYPE",
-	"STORAGE_INSUFFICIENT_QUOTA",
-	"STORAGE_NOT_FOUND",
-	"STORAGE_PERMISSION_DENIED",
-	"S3_ACCESS_KEY_LIMIT_EXCEEDED",
-	"S3_ACCESS_KEY_NOT_FOUND",
-	"S3_PROTOCOL_UNAVAILABLE",
-	"REALTIME_CHANNEL_NOT_FOUND",
-	"REALTIME_CONNECTION_FAILED",
-	"REALTIME_INVALID_CHANNEL_REQUEST",
-	"REALTIME_INVALID_CHANNEL_PATTERN",
-	"REALTIME_INVALID_EVENT",
-	"REALTIME_NOT_SUBSCRIBED",
-	"REALTIME_UNAUTHORIZED",
-	"AI_INVALID_API_KEY",
-	"AI_INVALID_MODEL",
-	"AI_UPSTREAM_UNAVAILABLE",
-	"ANALYTICS_NOT_CONNECTED",
-	"ANALYTICS_UNAVAILABLE",
-	"LOGS_AWS_NOT_CONFIGURED",
-	"LOG_NOT_FOUND",
-	"COMPUTE_CLOUD_UNAVAILABLE",
-	"COMPUTE_NOT_CONFIGURED",
-	"COMPUTE_PROVIDER_ERROR",
-	"COMPUTE_SERVICE_NOT_FOUND",
-	"COMPUTE_SERVICE_NOT_CONFIGURED",
-	"COMPUTE_SERVICE_DEPLOY_FAILED",
-	"COMPUTE_SERVICE_ALREADY_EXISTS",
-	"COMPUTE_SERVICE_START_FAILED",
-	"COMPUTE_SERVICE_STOP_FAILED",
-	"COMPUTE_SERVICE_DELETE_FAILED",
-	"COMPUTE_REGION_CHANGE_NOT_SUPPORTED",
-	"COMPUTE_QUOTA_EXCEEDED",
-	"BILLING_INSUFFICIENT_BALANCE",
-	"EMAIL_SMTP_CONNECTION_FAILED",
-	"EMAIL_SMTP_SEND_FAILED",
-	"EMAIL_TEMPLATE_NOT_FOUND",
-	"DEPLOYMENT_ALREADY_EXISTS",
-	"DEPLOYMENT_INVALID_FILE",
-	"DEPLOYMENT_NOT_FOUND",
-	"DEPLOYMENT_UPLOAD_CANCELED",
-	"DOMAIN_ALREADY_EXISTS",
-	"DOMAIN_INVALID",
-	"DOMAIN_NOT_FOUND",
-	"ENVIRONMENT_VARIABLE_NOT_FOUND",
-	"DOCS_NOT_FOUND",
-	"FUNCTION_ALREADY_EXISTS",
-	"FUNCTION_DEPLOYMENT_NOT_FOUND",
-	"FUNCTION_NOT_FOUND",
-	"SCHEDULE_INVALID_CRON",
-	"SCHEDULE_NOT_FOUND",
-	"PAYMENT_CHECKOUT_ALREADY_EXISTS",
-	"PAYMENT_CONFIG_INVALID",
-	"PAYMENT_CONFIG_NOT_FOUND",
-	"PAYMENT_NOT_FOUND",
-	"PAYMENT_METHOD_DECLINED",
-	"PAYMENT_PRICE_NOT_FOUND",
-	"PAYMENT_PRODUCT_NOT_FOUND",
-	"SECRET_ALREADY_EXISTS",
-	"SECRET_NOT_FOUND",
-	"MISSING_FIELD",
-	"ALREADY_EXISTS",
-	"INVALID_INPUT",
-	"NOT_FOUND",
-	"UNKNOWN_ERROR",
-	"INTERNAL_ERROR",
-	"TOO_MANY_REQUESTS",
-	"FORBIDDEN",
-	"RATE_LIMITED",
-	"NOT_IMPLEMENTED",
-	"UPSTREAM_FAILURE"
-]>;
-type ErrorCode = z.infer<typeof errorCodeSchema>;
-type InsForgeErrorCode = ErrorCode | (string & {});
-interface InsForgeConfig {
-	/**
-	 * The base URL of the InsForge backend API
-	 * @default "http://localhost:7130"
-	 */
-	baseUrl?: string;
-	/**
-	 * Anonymous API key (optional)
-	 * Used for public/unauthenticated requests when no user token is set
-	 */
-	anonKey?: string;
-	/**
-	 * Static access token (optional)
-	 * Seeds the client with a fixed bearer token used for all authenticated
-	 * requests — e.g. a user JWT inside an edge function, or a server-signed
-	 * JWT from an external auth provider. Disables automatic token refresh
-	 * and implies server mode unless `isServerMode` is set explicitly.
-	 */
-	accessToken?: string;
-	/**
-	 * @deprecated Use `accessToken` instead. Same behavior; `accessToken`
-	 * takes precedence when both are provided.
-	 */
-	edgeFunctionToken?: string;
-	/**
-	 * Direct URL to Deno Subhosting functions (optional)
-	 * When provided, SDK will try this URL first for function invocations.
-	 * Falls back to proxy URL if subhosting returns 404.
-	 * @example "https://{appKey}.functions.insforge.app"
-	 */
-	functionsUrl?: string;
-	/**
-	 * Custom fetch implementation (useful for Node.js environments)
-	 */
-	fetch?: typeof fetch;
-	/**
-	 * Enable server-side auth mode (SSR/Node runtime)
-	 * In this mode auth endpoints use `client_type=mobile` and refresh_token body flow.
-	 *
-	 * @deprecated Use `createServerClient()`, `createBrowserClient()`, and
-	 * `updateSession()` from `@resultdev/sdk/ssr` for SSR apps.
-	 * @default false
-	 */
-	isServerMode?: boolean;
-	/**
-	 * Advanced auth module options.
-	 */
-	auth?: {
-		/**
-		 * Detect and exchange OAuth callback parameters on browser client
-		 * initialization. SSR browser clients disable this so auth mutations can
-		 * stay server-owned.
-		 * @default true
-		 */
-		detectOAuthCallback?: boolean;
-	};
-	/**
-	 * Database module options.
-	 */
-	db?: {
-		/**
-		 * Default Postgres schema for database queries. Maps to PostgREST's
-		 * `Accept-Profile`/`Content-Profile` headers. Override per-query with
-		 * `client.database.schema('other')`.
-		 * @default "public"
-		 */
-		schema?: string;
-	};
-	/**
-	 * Custom headers to include with every request
-	 */
-	headers?: Record<string, string>;
-	/**
-	 * Enable debug logging for HTTP requests and responses.
-	 * When true, request/response details are logged to the console.
-	 * Can also be a custom log function for advanced use cases.
-	 * @default false
-	 */
-	debug?: boolean | ((message: string, ...args: any[]) => void);
-	/**
-	 * Request timeout in milliseconds.
-	 * Requests that exceed this duration will be aborted.
-	 * Set to 0 to disable timeout.
-	 * @default 30000
-	 */
-	timeout?: number;
-	/**
-	 * Maximum number of retry attempts for failed requests.
-	 * Retries are triggered on network errors and server errors (5xx).
-	 * Client errors (4xx) are never retried.
-	 * Set to 0 to disable retries.
-	 * @default 3
-	 */
-	retryCount?: number;
-	/**
-	 * Initial delay in milliseconds before the first retry.
-	 * The delay doubles with each subsequent attempt (exponential backoff)
-	 * with ±15% jitter to prevent thundering herd.
-	 * @default 500
-	 */
-	retryDelay?: number;
-}
-interface ApiError {
-	error: InsForgeErrorCode;
-	message: string;
-	statusCode: number;
-	nextActions?: string;
-}
-declare class InsForgeError extends Error {
-	statusCode: number;
-	error: InsForgeErrorCode;
-	nextActions?: string;
-	constructor(message: string, statusCode: number, error: InsForgeErrorCode, nextActions?: string);
-	static fromApiError(apiError: ApiError): InsForgeError;
-}
-export declare const DEFAULT_ACCESS_TOKEN_COOKIE = "insforge_access_token";
-export declare const DEFAULT_REFRESH_TOKEN_COOKIE = "insforge_refresh_token";
-export interface AuthCookieNames {
-	accessToken?: string;
-	refreshToken?: string;
-}
-export interface CookieOptions {
-	domain?: string;
-	path?: string;
-	expires?: Date;
-	maxAge?: number;
-	httpOnly?: boolean;
-	secure?: boolean;
-	sameSite?: "lax" | "strict" | "none";
-}
-export interface AuthCookieOptions {
-	accessToken?: CookieOptions;
-	refreshToken?: CookieOptions;
-}
-type CookieStoreValue = string | {
-	value?: string | null;
-} | undefined | null;
-export interface CookieReader {
-	get(name: string): CookieStoreValue;
-}
-export interface CookieWriter {
-	set?(name: string, value: string, options?: CookieOptions): unknown;
-	set?(options: {
-		name: string;
-		value: string;
-	} & CookieOptions): unknown;
-	delete?(name: string): unknown;
-	delete?(options: {
-		name: string;
-	} & CookieOptions): unknown;
-}
-interface CookieStore$1 extends CookieReader, CookieWriter {
-}
-export interface AuthCookieSettings {
-	names?: AuthCookieNames;
-	options?: AuthCookieOptions;
-}
-export declare function getAccessTokenCookieName(names?: AuthCookieNames): string;
-export declare function getRefreshTokenCookieName(names?: AuthCookieNames): string;
-export declare function setAuthCookies(cookies: CookieWriter | undefined, tokens: {
-	accessToken: string;
-	refreshToken?: string | null;
-}, settings?: AuthCookieSettings): void;
-export declare function clearAuthCookies(cookies: CookieWriter | undefined, settings?: AuthCookieSettings): void;
-export interface UpdateSessionOptions extends Omit<InsForgeConfig, "accessToken" | "edgeFunctionToken" | "isServerMode" | "auth">, AuthCookieSettings {
-	requestCookies: CookieStore$1;
-	responseCookies: CookieStore$1;
-	refreshLeewaySeconds?: number;
-}
-export interface UpdateSessionResult {
-	refreshed: boolean;
-	accessToken: string | null;
-	error: InsForgeError | null;
-}
-export declare function updateSession(options: UpdateSessionOptions): Promise<UpdateSessionResult>;
-
-declare namespace z {
-	export { AnyZodObject, AnyZodTuple, ArrayCardinality, ArrayKeys, AssertArray, AsyncParseReturnType, BRAND, CatchallInput, CatchallOutput, CustomErrorParams, DIRTY, DenormalizedError, EMPTY_PATH, Effect, EnumLike, EnumValues, ErrorMapCtx, FilterEnum, INVALID, Indices, InnerTypeOfFunction, InputTypeOfTuple, InputTypeOfTupleWithRest, IpVersion, IssueData, KeySchema, NEVER, OK, ObjectPair, OuterTypeOfFunction, OutputTypeOfTuple, OutputTypeOfTupleWithRest, ParseContext, ParseInput, ParseParams, ParsePath, ParsePathComponent, ParseResult, ParseReturnType, ParseStatus, PassthroughType, PreprocessEffect, Primitive, ProcessedCreateParams, RawCreateParams, RecordType, Refinement, RefinementCtx, RefinementEffect, SafeParseError, SafeParseReturnType, SafeParseSuccess, Scalars, SomeZodObject, StringValidation, SuperRefinement, SyncParseReturnType, TransformEffect, TypeOf, TypeOf as infer, UnknownKeysParam, Values, Writeable, ZodAny, ZodAnyDef, ZodArray, ZodArrayDef, ZodBigInt, ZodBigIntCheck, ZodBigIntDef, ZodBoolean, ZodBooleanDef, ZodBranded, ZodBrandedDef, ZodCatch, ZodCatchDef, ZodCustomIssue, ZodDate, ZodDateCheck, ZodDateDef, ZodDefault, ZodDefaultDef, ZodDiscriminatedUnion, ZodDiscriminatedUnionDef, ZodDiscriminatedUnionOption, ZodEffects, ZodEffects as ZodTransformer, ZodEffectsDef, ZodEnum, ZodEnumDef, ZodError, ZodErrorMap, ZodFirstPartySchemaTypes, ZodFirstPartyTypeKind, ZodFormattedError, ZodFunction, ZodFunctionDef, ZodIntersection, ZodIntersectionDef, ZodInvalidArgumentsIssue, ZodInvalidDateIssue, ZodInvalidEnumValueIssue, ZodInvalidIntersectionTypesIssue, ZodInvalidLiteralIssue, ZodInvalidReturnTypeIssue, ZodInvalidStringIssue, ZodInvalidTypeIssue, ZodInvalidUnionDiscriminatorIssue, ZodInvalidUnionIssue, ZodIssue, ZodIssueBase, ZodIssueCode, ZodIssueOptionalMessage, ZodLazy, ZodLazyDef, ZodLiteral, ZodLiteralDef, ZodMap, ZodMapDef, ZodNaN, ZodNaNDef, ZodNativeEnum, ZodNativeEnumDef, ZodNever, ZodNeverDef, ZodNonEmptyArray, ZodNotFiniteIssue, ZodNotMultipleOfIssue, ZodNull, ZodNullDef, ZodNullable, ZodNullableDef, ZodNullableType, ZodNumber, ZodNumberCheck, ZodNumberDef, ZodObject, ZodObjectDef, ZodOptional, ZodOptionalDef, ZodOptionalType, ZodParsedType, ZodPipeline, ZodPipelineDef, ZodPromise, ZodPromiseDef, ZodRawShape, ZodReadonly, ZodReadonlyDef, ZodRecord, ZodRecordDef, ZodSet, ZodSetDef, ZodString, ZodStringCheck, ZodStringDef, ZodSymbol, ZodSymbolDef, ZodTooBigIssue, ZodTooSmallIssue, ZodTuple, ZodTupleDef, ZodTupleItems, ZodType, ZodType as Schema, ZodType as ZodSchema, ZodTypeAny, ZodTypeDef, ZodUndefined, ZodUndefinedDef, ZodUnion, ZodUnionDef, ZodUnionOptions, ZodUnknown, ZodUnknownDef, ZodUnrecognizedKeysIssue, ZodVoid, ZodVoidDef, addIssueToContext, anyType as any, arrayOutputType, arrayType as array, baseObjectInputType, baseObjectOutputType, bigIntType as bigint, booleanType as boolean, coerce, custom, dateType as date, datetimeRegex, deoptional, discriminatedUnionType as discriminatedUnion, effectsType as effect, effectsType as transformer, enumType as enum, errorMap as defaultErrorMap, functionType as function, getErrorMap, getParsedType, inferFlattenedErrors, inferFormattedError, input, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, mergeTypes, nanType as nan, nativeEnumType as nativeEnum, neverType as never, noUnrecognized, nullType as null, nullableType as nullable, numberType as number, objectInputType, objectOutputType, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, output, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setErrorMap, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, tupleType as tuple, typeToFlattenedError, typecast, undefinedType as undefined, unionType as union, unknownType as unknown, util, voidType as void };
-}
-
-export {
-	CookieStore$1 as CookieStore,
-};
-
-export {};
+export { b as AuthCookieNames, c as AuthCookieOptions, A as AuthCookieSettings, d as CookieOptions, e as CookieReader, C as CookieStore, a as CookieWriter, D as DEFAULT_ACCESS_TOKEN_COOKIE, f as DEFAULT_REFRESH_TOKEN_COOKIE, U as UpdateSessionOptions, g as UpdateSessionResult, i as clearAuthCookies, j as getAccessTokenCookieName, k as getRefreshTokenCookieName, s as setAuthCookies, u as updateSession } from '../middleware-BJl9JRg3.js';
+import '../types-DSVtGaIA.js';