// Generated by dts-bundle-generator v9.5.1

export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
export type _JSONSchema = boolean | JSONSchema;
export type JSONSchema = {
	[k: string]: unknown;
	$schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
	$id?: string;
	$anchor?: string;
	$ref?: string;
	$dynamicRef?: string;
	$dynamicAnchor?: string;
	$vocabulary?: Record<string, boolean>;
	$comment?: string;
	$defs?: Record<string, JSONSchema>;
	type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
	additionalItems?: _JSONSchema;
	unevaluatedItems?: _JSONSchema;
	prefixItems?: _JSONSchema[];
	items?: _JSONSchema | _JSONSchema[];
	contains?: _JSONSchema;
	additionalProperties?: _JSONSchema;
	unevaluatedProperties?: _JSONSchema;
	properties?: Record<string, _JSONSchema>;
	patternProperties?: Record<string, _JSONSchema>;
	dependentSchemas?: Record<string, _JSONSchema>;
	propertyNames?: _JSONSchema;
	if?: _JSONSchema;
	then?: _JSONSchema;
	else?: _JSONSchema;
	allOf?: JSONSchema[];
	anyOf?: JSONSchema[];
	oneOf?: JSONSchema[];
	not?: _JSONSchema;
	multipleOf?: number;
	maximum?: number;
	exclusiveMaximum?: number | boolean;
	minimum?: number;
	exclusiveMinimum?: number | boolean;
	maxLength?: number;
	minLength?: number;
	pattern?: string;
	maxItems?: number;
	minItems?: number;
	uniqueItems?: boolean;
	maxContains?: number;
	minContains?: number;
	maxProperties?: number;
	minProperties?: number;
	required?: string[];
	dependentRequired?: Record<string, string[]>;
	enum?: Array<string | number | boolean | null>;
	const?: string | number | boolean | null;
	id?: string;
	title?: string;
	description?: string;
	default?: unknown;
	deprecated?: boolean;
	readOnly?: boolean;
	writeOnly?: boolean;
	nullable?: boolean;
	examples?: unknown[];
	format?: string;
	contentMediaType?: string;
	contentEncoding?: string;
	contentSchema?: JSONSchema;
	_prefault?: unknown;
};
export type BaseSchema = JSONSchema;
export interface ObjectSchema extends JSONSchema {
	type: "object";
}
export interface ArraySchema extends JSONSchema {
	type: "array";
}
export interface StringSchema extends JSONSchema {
	type: "string";
}
export interface NumberSchema extends JSONSchema {
	type: "number";
}
export interface IntegerSchema extends JSONSchema {
	type: "integer";
}
export interface BooleanSchema extends JSONSchema {
	type: "boolean";
}
export interface NullSchema extends JSONSchema {
	type: "null";
}
/** The Standard interface. */
export interface StandardTypedV1<Input = unknown, Output = Input> {
	/** The Standard properties. */
	readonly "~standard": StandardTypedV1.Props<Input, Output>;
}
declare namespace StandardTypedV1 {
	/** The Standard 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;
		/** Inferred types associated with the schema. */
		readonly types?: Types<Input, Output> | undefined;
	}
	/** The Standard 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. */
	type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
	/** Infers the output type of a Standard. */
	type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
}
/** The Standard Schema interface. */
export 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> extends StandardTypedV1.Props<Input, Output> {
		/** Validates unknown input values. */
		readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
	}
	/** 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 absence of issues indicates success. */
		readonly issues?: undefined;
	}
	interface Options {
		/** Implicit support for additional vendor-specific parameters, if needed. */
		readonly libraryOptions?: Record<string, unknown> | 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 types interface. */
	interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
	}
	/** Infers the input type of a Standard. */
	type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
	/** Infers the output type of a Standard. */
	type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
}
/** The Standard JSON Schema interface. */
export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
	/** The Standard JSON Schema properties. */
	readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
}
declare namespace StandardJSONSchemaV1 {
	/** The Standard JSON Schema properties interface. */
	interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
		/** Methods for generating the input/output JSON Schema. */
		readonly jsonSchema: Converter;
	}
	/** The Standard JSON Schema converter interface. */
	interface Converter {
		/** Converts the input type to JSON Schema. May throw if conversion is not supported. */
		readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
		/** Converts the output type to JSON Schema. May throw if conversion is not supported. */
		readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
	}
	/** The target version of the generated JSON Schema.
	 *
	 * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
	 *
	 * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
	 *
	 * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
	 */
	type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
	/** The options for the input/output methods. */
	interface Options {
		/** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
		readonly target: Target;
		/** Implicit support for additional vendor-specific parameters, if needed. */
		readonly libraryOptions?: Record<string, unknown> | undefined;
	}
	/** The Standard types interface. */
	interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
	}
	/** Infers the input type of a Standard. */
	type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
	/** Infers the output type of a Standard. */
	type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
}
export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
}
declare const $output: unique symbol;
export type $output = typeof $output;
declare const $input: unique symbol;
export type $input = typeof $input;
export 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;
export type MetadataType = object | 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;
	clear(): this;
	remove(schema: Schema): this;
	get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
	has(schema: Schema): boolean;
}
export interface JSONSchemaMeta {
	id?: string | undefined;
	title?: string | undefined;
	description?: string | undefined;
	deprecated?: boolean | undefined;
	[k: string]: unknown;
}
export interface GlobalMeta extends JSONSchemaMeta {
}
declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
declare const globalRegistry: $ZodRegistry<GlobalMeta>;
export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: JSONSchema$1.BaseSchema, params: ProcessParams) => void;
export interface JSONSchemaGeneratorParams {
	processors: Record<string, Processor>;
	/** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
	 *  @default globalRegistry */
	metadata?: $ZodRegistry<Record<string, any>>;
	/** The JSON Schema version to target.
	 * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
	 * - `"draft-07"` — JSON Schema Draft 7
	 * - `"draft-04"` — JSON Schema Draft 4
	 * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
	target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
	/** How to handle unrepresentable types.
	 * - `"throw"` — Default. Unrepresentable types throw an error
	 * - `"any"` — Unrepresentable types become `{}` */
	unrepresentable?: "throw" | "any";
	/** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
	override?: (ctx: {
		zodSchema: schemas.$ZodTypes;
		jsonSchema: JSONSchema$1.BaseSchema;
		path: (string | number)[];
	}) => void;
	/** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
	 * - `"output"` — Default. Convert the output schema.
	 * - `"input"` — Convert the input schema. */
	io?: "input" | "output";
	cycles?: "ref" | "throw";
	reused?: "ref" | "inline";
	external?: {
		registry: $ZodRegistry<{
			id?: string | undefined;
		}>;
		uri?: ((id: string) => string) | undefined;
		defs: Record<string, JSONSchema$1.BaseSchema>;
	} | undefined;
}
/**
 * Parameters for the toJSONSchema function.
 */
export type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
/**
 * Parameters for the toJSONSchema function when passing a registry.
 */
export interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
	uri?: (id: string) => string;
}
export interface ProcessParams {
	schemaPath: schemas.$ZodType[];
	path: (string | number)[];
}
export interface Seen {
	/** JSON Schema result for this Zod schema */
	schema: JSONSchema$1.BaseSchema;
	/** A cached version of the schema that doesn't get overwritten during ref resolution */
	def?: JSONSchema$1.BaseSchema;
	defId?: string | undefined;
	/** Number of times this schema was encountered during traversal */
	count: number;
	/** Cycle path */
	cycle?: (string | number)[] | undefined;
	isParent?: boolean | undefined;
	/** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
	ref?: schemas.$ZodType | null;
	/** JSON Schema property path for this schema */
	path?: (string | number)[] | undefined;
}
export interface ToJSONSchemaContext {
	processors: Record<string, Processor>;
	metadataRegistry: $ZodRegistry<Record<string, any>>;
	target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
	unrepresentable: "throw" | "any";
	override: (ctx: {
		zodSchema: schemas.$ZodType;
		jsonSchema: JSONSchema$1.BaseSchema;
		path: (string | number)[];
	}) => void;
	io: "input" | "output";
	counter: number;
	seen: Map<schemas.$ZodType, Seen>;
	cycles: "ref" | "throw";
	reused: "ref" | "inline";
	external?: {
		registry: $ZodRegistry<{
			id?: string | undefined;
		}>;
		uri?: ((id: string) => string) | undefined;
		defs: Record<string, JSONSchema$1.BaseSchema>;
	} | undefined;
}
declare function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext;
declare function process$1<T extends schemas.$ZodType>(schema: T, ctx: ToJSONSchemaContext, _params?: ProcessParams): JSONSchema$1.BaseSchema;
declare function extractDefs<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): void;
declare function finalize<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;
export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
export interface ZodStandardJSONSchemaPayload<T> extends JSONSchema$1.BaseSchema {
	"~standard": ZodStandardSchemaWithJSON<T>;
}
declare const createToJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, processors?: Record<string, Processor>) => (params?: ToJSONSchemaParams) => ZodStandardJSONSchemaPayload<T>;
/**
 * Creates a toJSONSchema method for a schema instance.
 * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
 */
export type StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1["~standard"]["jsonSchema"]["input"]>[0];
declare const createStandardJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, io: "input" | "output", processors?: Record<string, Processor>) => (params?: StandardJSONSchemaMethodParams) => JSONSchema$1.BaseSchema;
export type JSONType = string | number | boolean | null | JSONType[] | {
	[key: string]: JSONType;
};
export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
export type HashEncoding = "hex" | "base64" | "base64url";
export type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
export type IPVersion = "v4" | "v6";
export type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
export type ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
export type AssertExtends<T, U> = T extends U ? T : never;
export type IsAny<T> = 0 extends 1 & T ? true : false;
type Omit$1<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$1<T, K> & InexactPartial<Pick<T, K>>;
export type MakeRequired<T, K extends keyof T> = Omit$1<T, K> & Required<Pick<T, K>>;
export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
export type NoUndefined<T> = T extends undefined ? never : T;
export type Whatever = {} | undefined | null;
export type LoosePartial<T extends object> = InexactPartial<T> & {
	[k: string]: unknown;
};
export type Mask<Keys extends PropertyKey> = {
	[K in Keys]?: true;
};
export type Writeable<T> = {
	-readonly [P in keyof T]: T[P];
} & {};
export type InexactPartial<T> = {
	[P in keyof T]?: T[P] | undefined;
};
export type EmptyObject = Record<string, never>;
export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
	readonly [Symbol.toStringTag]: string;
} | Date | Error | Generator | Promise<unknown> | RegExp;
export 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>;
export type SomeObject = Record<PropertyKey, any>;
export type Identity<T> = T;
export type Flatten<T> = Identity<{
	[k in keyof T]: T[k];
}>;
export type Mapped<T> = {
	[k in keyof T]: T[k];
};
export type Prettify<T> = {
	[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 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];
}>;
export type TupleItems = ReadonlyArray<schemas.SomeType>;
export type AnyFunc = (...args: any[]) => any;
export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
export type MaybeAsync<T> = T | Promise<T>;
export type KeyOf<T> = keyof OmitIndexSignature<T>;
export type OmitIndexSignature<T> = {
	[K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
};
export type ExtractIndexSignature<T> = {
	[K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
};
export type Keys<T extends object> = keyof OmitIndexSignature<T>;
export type SchemaClass<T extends schemas.SomeType> = {
	new (def: T["_zod"]["def"]): T;
};
export type EnumValue = string | number;
export type EnumLike = Readonly<Record<string, EnumValue>>;
export type ToEnum<T extends EnumValue> = Flatten<{
	[k in T]: k;
}>;
export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
export type Literal = string | number | bigint | boolean | null | undefined;
export type LiteralArray = Array<Literal>;
export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
export type PrimitiveArray = Array<Primitive>;
export type HasSize = {
	size: number;
};
export type HasLength = {
	length: number;
};
export type Numeric = number | bigint | Date;
export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
export type SafeParseSuccess<T> = {
	success: true;
	data: T;
	error?: never;
};
export type SafeParseError<T> = {
	success: false;
	data?: never;
	error: $ZodError<T>;
};
export type PropValues = Record<string, Set<Primitive>>;
export type PrimitiveSet = Set<Primitive>;
declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
declare function assertIs<T>(_arg: T): void;
declare function assertNever(_x: never): never;
declare function assert<T>(_: any): asserts _ is T;
declare function getEnumValues(entries: EnumLike): EnumValue[];
declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
declare function jsonStringifyReplacer(_: string, value: any): any;
declare function cached<T>(getter: () => T): {
	value: T;
};
declare function nullish(input: any): boolean;
declare function cleanRegex(source: string): string;
declare function floatSafeRemainder(val: number, step: number): number;
declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
declare function objectClone(obj: object): any;
declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
declare function mergeDefs(...defs: Record<string, any>[]): any;
declare function cloneDef(schema: schemas.$ZodType): any;
declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
	[k in keyof T]: Awaited<T[k]>;
}>;
declare function randomString(length?: number): string;
declare function esc(str: string): string;
declare function slugify(input: string): string;
declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
declare function isObject(data: any): data is Record<PropertyKey, unknown>;
declare const allowsEval: {
	value: boolean;
};
declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
declare function shallowClone(o: any): any;
declare function numKeys(data: any): number;
declare const getParsedType: (data: any) => ParsedTypes;
declare const propertyKeyTypes: Set<string>;
declare const primitiveTypes: Set<string>;
declare function escapeRegex(str: string): string;
declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
	parent: boolean;
}): T;
export type EmptyToNever<T> = keyof T extends never ? never : T;
export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
	[k in keyof Omit$1<T, "error" | "message">]: T[k];
} & ("error" extends keyof T ? {
	error?: Exclude<T["error"], string>;
} : unknown)> : never;
declare function normalizeParams<T>(_params: T): Normalize<T>;
declare function createTransparentProxy<T extends object>(getter: () => T): T;
declare function stringifyPrimitive(value: any): string;
declare function optionalKeys(shape: schemas.$ZodShape): string[];
export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
	[k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
};
export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
	[k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
};
declare const NUMBER_FORMAT_RANGES: Record<$ZodNumberFormats, [
	number,
	number
]>;
declare const BIGINT_FORMAT_RANGES: Record<$ZodBigIntFormats, [
	bigint,
	bigint
]>;
declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
declare function omit(schema: schemas.$ZodObject, mask: object): any;
declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
declare function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined): any;
declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
declare function prefixIssues(path: PropertyKey, issues: $ZodRawIssue[]): $ZodRawIssue[];
declare function unwrapMessage(message: string | {
	message: string;
} | undefined | null): string | undefined;
declare function finalizeIssue(iss: $ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): $ZodIssue;
declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
declare function parsedType(data: unknown): $ZodInvalidTypeExpected;
declare function issue(_iss: string, input: any, inst: any): $ZodRawIssue;
declare function issue(_iss: $ZodRawIssue): $ZodRawIssue;
declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;
declare function uint8ArrayToBase64(bytes: Uint8Array): string;
declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;
declare function uint8ArrayToBase64url(bytes: Uint8Array): string;
declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;
declare function uint8ArrayToHex(bytes: Uint8Array): string;
declare abstract class Class {
	constructor(..._args: any[]);
}
declare const version: {
	readonly major: 4;
	readonly minor: 3;
	readonly patch: number;
};
export 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 */
export interface ParseContextInternal<T extends $ZodIssueBase = never> extends ParseContext<T> {
	readonly async?: boolean | undefined;
	readonly direction?: "forward" | "backward";
	readonly skipChecks?: boolean;
}
export interface ParsePayload<T = unknown> {
	value: T;
	issues: $ZodRawIssue[];
	/** A may to mark a whole payload as aborted. Used in codecs/pipes. */
	aborted?: boolean;
}
export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
export interface $ZodTypeDef {
	type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
	error?: $ZodErrorMap<never> | undefined;
	checks?: $ZodCheck<never>[];
}
export interface _$ZodTypeInternals {
	/** The `@zod/core` version of this schema */
	version: typeof version;
	/** Schema definition. */
	def: $ZodTypeDef;
	/** @internal Randomly generated ID for this schema. */
	/** @internal List of deferred initializers. */
	deferred: util.AnyFunc[] | undefined;
	/** @internal Parses input and runs all checks (refinements). */
	run(payload: ParsePayload<any>, ctx: ParseContextInternal): util.MaybeAsync<ParsePayload>;
	/** @internal Parses input, doesn't run checks. */
	parse(payload: ParsePayload<any>, ctx: ParseContextInternal): util.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?: util.PrimitiveSet | undefined;
	/** Default value bubbled up from  */
	/** @internal A set of literal discriminators used for the fast path in discriminated unions. */
	propValues?: util.PropValues | undefined;
	/** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
	pattern: RegExp | undefined;
	/** @internal The constructor function of this schema. */
	constr: new (def: any) => $ZodType;
	/** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
	bag: Record<string, unknown>;
	/** @internal The set of issues this schema might throw during type checking. */
	isst: $ZodIssueBase;
	/** @internal Subject to change, not a public API. */
	processJSONSchema?: ((ctx: ToJSONSchemaContext, json: JSONSchema$1.BaseSchema, params: ProcessParams) => void) | undefined;
	/** An optional method used to override `toJSONSchema` logic. */
	toJSONSchema?: () => unknown;
	/** @internal The parent of this schema. Only set during certain clone operations. */
	parent?: $ZodType | undefined;
}
/** @internal */
export interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
	/** @internal The inferred output type */
	output: O;
	/** @internal The inferred input type */
	input: I;
}
export type $ZodStandardSchema<T> = StandardSchemaV1.Props<input<T>, output<T>>;
export type SomeType = {
	_zod: _$ZodTypeInternals;
};
export interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
	_zod: Internals;
	"~standard": $ZodStandardSchema<this>;
}
export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {
}
declare const $ZodType: $constructor<$ZodType>;
export interface $ZodStringDef extends $ZodTypeDef {
	type: "string";
	coerce?: boolean;
	checks?: $ZodCheck<string>[];
}
export 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: util.LoosePartial<{
		minimum: number;
		maximum: number;
		patterns: Set<RegExp>;
		format: string;
		contentEncoding: string;
	}>;
}
export interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {
}
declare const $ZodString: $constructor<$ZodString>;
export interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {
}
export interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
	def: $ZodStringFormatDef<Format>;
}
export interface $ZodStringFormat<Format extends string = string> extends $ZodType {
	_zod: $ZodStringFormatInternals<Format>;
}
declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
export interface $ZodGUIDDef extends $ZodStringFormatDef<"guid"> {
}
export interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {
}
export interface $ZodGUID extends $ZodType {
	_zod: $ZodGUIDInternals;
}
declare const $ZodGUID: $constructor<$ZodGUID>;
export interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
	version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
}
export interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
	def: $ZodUUIDDef;
}
export interface $ZodUUID extends $ZodType {
	_zod: $ZodUUIDInternals;
}
declare const $ZodUUID: $constructor<$ZodUUID>;
export interface $ZodEmailDef extends $ZodStringFormatDef<"email"> {
}
export interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {
}
export interface $ZodEmail extends $ZodType {
	_zod: $ZodEmailInternals;
}
declare const $ZodEmail: $constructor<$ZodEmail>;
export interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
	hostname?: RegExp | undefined;
	protocol?: RegExp | undefined;
	normalize?: boolean | undefined;
}
export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
	def: $ZodURLDef;
}
export interface $ZodURL extends $ZodType {
	_zod: $ZodURLInternals;
}
declare const $ZodURL: $constructor<$ZodURL>;
export interface $ZodEmojiDef extends $ZodStringFormatDef<"emoji"> {
}
export interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {
}
export interface $ZodEmoji extends $ZodType {
	_zod: $ZodEmojiInternals;
}
declare const $ZodEmoji: $constructor<$ZodEmoji>;
export interface $ZodNanoIDDef extends $ZodStringFormatDef<"nanoid"> {
}
export interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {
}
export interface $ZodNanoID extends $ZodType {
	_zod: $ZodNanoIDInternals;
}
declare const $ZodNanoID: $constructor<$ZodNanoID>;
export interface $ZodCUIDDef extends $ZodStringFormatDef<"cuid"> {
}
export interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {
}
export interface $ZodCUID extends $ZodType {
	_zod: $ZodCUIDInternals;
}
declare const $ZodCUID: $constructor<$ZodCUID>;
export interface $ZodCUID2Def extends $ZodStringFormatDef<"cuid2"> {
}
export interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {
}
export interface $ZodCUID2 extends $ZodType {
	_zod: $ZodCUID2Internals;
}
declare const $ZodCUID2: $constructor<$ZodCUID2>;
export interface $ZodULIDDef extends $ZodStringFormatDef<"ulid"> {
}
export interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {
}
export interface $ZodULID extends $ZodType {
	_zod: $ZodULIDInternals;
}
declare const $ZodULID: $constructor<$ZodULID>;
export interface $ZodXIDDef extends $ZodStringFormatDef<"xid"> {
}
export interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {
}
export interface $ZodXID extends $ZodType {
	_zod: $ZodXIDInternals;
}
declare const $ZodXID: $constructor<$ZodXID>;
export interface $ZodKSUIDDef extends $ZodStringFormatDef<"ksuid"> {
}
export interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {
}
export interface $ZodKSUID extends $ZodType {
	_zod: $ZodKSUIDInternals;
}
declare const $ZodKSUID: $constructor<$ZodKSUID>;
export interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
	precision: number | null;
	offset: boolean;
	local: boolean;
}
export interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
	def: $ZodISODateTimeDef;
}
export interface $ZodISODateTime extends $ZodType {
	_zod: $ZodISODateTimeInternals;
}
declare const $ZodISODateTime: $constructor<$ZodISODateTime>;
export interface $ZodISODateDef extends $ZodStringFormatDef<"date"> {
}
export interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {
}
export interface $ZodISODate extends $ZodType {
	_zod: $ZodISODateInternals;
}
declare const $ZodISODate: $constructor<$ZodISODate>;
export interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
	precision?: number | null;
}
export interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
	def: $ZodISOTimeDef;
}
export interface $ZodISOTime extends $ZodType {
	_zod: $ZodISOTimeInternals;
}
declare const $ZodISOTime: $constructor<$ZodISOTime>;
export interface $ZodISODurationDef extends $ZodStringFormatDef<"duration"> {
}
export interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {
}
export interface $ZodISODuration extends $ZodType {
	_zod: $ZodISODurationInternals;
}
declare const $ZodISODuration: $constructor<$ZodISODuration>;
export interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
	version?: "v4";
}
export interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
	def: $ZodIPv4Def;
}
export interface $ZodIPv4 extends $ZodType {
	_zod: $ZodIPv4Internals;
}
declare const $ZodIPv4: $constructor<$ZodIPv4>;
export interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
	version?: "v6";
}
export interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
	def: $ZodIPv6Def;
}
export interface $ZodIPv6 extends $ZodType {
	_zod: $ZodIPv6Internals;
}
declare const $ZodIPv6: $constructor<$ZodIPv6>;
export interface $ZodMACDef extends $ZodStringFormatDef<"mac"> {
	delimiter?: string;
}
export interface $ZodMACInternals extends $ZodStringFormatInternals<"mac"> {
	def: $ZodMACDef;
}
export interface $ZodMAC extends $ZodType {
	_zod: $ZodMACInternals;
}
declare const $ZodMAC: $constructor<$ZodMAC>;
export interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
	version?: "v4";
}
export interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
	def: $ZodCIDRv4Def;
}
export interface $ZodCIDRv4 extends $ZodType {
	_zod: $ZodCIDRv4Internals;
}
declare const $ZodCIDRv4: $constructor<$ZodCIDRv4>;
export interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
	version?: "v6";
}
export interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
	def: $ZodCIDRv6Def;
}
export interface $ZodCIDRv6 extends $ZodType {
	_zod: $ZodCIDRv6Internals;
}
declare const $ZodCIDRv6: $constructor<$ZodCIDRv6>;
declare function isValidBase64(data: string): boolean;
export interface $ZodBase64Def extends $ZodStringFormatDef<"base64"> {
}
export interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {
}
export interface $ZodBase64 extends $ZodType {
	_zod: $ZodBase64Internals;
}
declare const $ZodBase64: $constructor<$ZodBase64>;
declare function isValidBase64URL(data: string): boolean;
export interface $ZodBase64URLDef extends $ZodStringFormatDef<"base64url"> {
}
export interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {
}
export interface $ZodBase64URL extends $ZodType {
	_zod: $ZodBase64URLInternals;
}
declare const $ZodBase64URL: $constructor<$ZodBase64URL>;
export interface $ZodE164Def extends $ZodStringFormatDef<"e164"> {
}
export interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {
}
export interface $ZodE164 extends $ZodType {
	_zod: $ZodE164Internals;
}
declare const $ZodE164: $constructor<$ZodE164>;
declare function isValidJWT(token: string, algorithm?: util.JWTAlgorithm | null): boolean;
export interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
	alg?: util.JWTAlgorithm | undefined;
}
export interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
	def: $ZodJWTDef;
}
export interface $ZodJWT extends $ZodType {
	_zod: $ZodJWTInternals;
}
declare const $ZodJWT: $constructor<$ZodJWT>;
export interface $ZodCustomStringFormatDef<Format extends string = string> extends $ZodStringFormatDef<Format> {
	fn: (val: string) => unknown;
}
export interface $ZodCustomStringFormatInternals<Format extends string = string> extends $ZodStringFormatInternals<Format> {
	def: $ZodCustomStringFormatDef<Format>;
}
export interface $ZodCustomStringFormat<Format extends string = string> extends $ZodStringFormat<Format> {
	_zod: $ZodCustomStringFormatInternals<Format>;
}
declare const $ZodCustomStringFormat: $constructor<$ZodCustomStringFormat>;
export interface $ZodNumberDef extends $ZodTypeDef {
	type: "number";
	coerce?: boolean;
}
export interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
	def: $ZodNumberDef;
	/** @deprecated Internal API, use with caution (not deprecated) */
	pattern: RegExp;
	/** @deprecated Internal API, use with caution (not deprecated) */
	isst: $ZodIssueInvalidType;
	bag: util.LoosePartial<{
		minimum: number;
		maximum: number;
		exclusiveMinimum: number;
		exclusiveMaximum: number;
		format: string;
		pattern: RegExp;
	}>;
}
export interface $ZodNumber<Input = unknown> extends $ZodType {
	_zod: $ZodNumberInternals<Input>;
}
declare const $ZodNumber: $constructor<$ZodNumber>;
export interface $ZodNumberFormatDef extends $ZodNumberDef, $ZodCheckNumberFormatDef {
}
export interface $ZodNumberFormatInternals extends $ZodNumberInternals<number>, $ZodCheckNumberFormatInternals {
	def: $ZodNumberFormatDef;
	isst: $ZodIssueInvalidType;
}
export interface $ZodNumberFormat extends $ZodType {
	_zod: $ZodNumberFormatInternals;
}
declare const $ZodNumberFormat: $constructor<$ZodNumberFormat>;
export interface $ZodBooleanDef extends $ZodTypeDef {
	type: "boolean";
	coerce?: boolean;
	checks?: $ZodCheck<boolean>[];
}
export interface $ZodBooleanInternals<T = unknown> extends $ZodTypeInternals<boolean, T> {
	pattern: RegExp;
	def: $ZodBooleanDef;
	isst: $ZodIssueInvalidType;
}
export interface $ZodBoolean<T = unknown> extends $ZodType {
	_zod: $ZodBooleanInternals<T>;
}
declare const $ZodBoolean: $constructor<$ZodBoolean>;
export interface $ZodBigIntDef extends $ZodTypeDef {
	type: "bigint";
	coerce?: boolean;
}
export interface $ZodBigIntInternals<T = unknown> extends $ZodTypeInternals<bigint, T> {
	pattern: RegExp;
	/** @internal Internal API, use with caution */
	def: $ZodBigIntDef;
	isst: $ZodIssueInvalidType;
	bag: util.LoosePartial<{
		minimum: bigint;
		maximum: bigint;
		format: string;
	}>;
}
export interface $ZodBigInt<T = unknown> extends $ZodType {
	_zod: $ZodBigIntInternals<T>;
}
declare const $ZodBigInt: $constructor<$ZodBigInt>;
export interface $ZodBigIntFormatDef extends $ZodBigIntDef, $ZodCheckBigIntFormatDef {
	check: "bigint_format";
}
export interface $ZodBigIntFormatInternals extends $ZodBigIntInternals<bigint>, $ZodCheckBigIntFormatInternals {
	def: $ZodBigIntFormatDef;
}
export interface $ZodBigIntFormat extends $ZodType {
	_zod: $ZodBigIntFormatInternals;
}
declare const $ZodBigIntFormat: $constructor<$ZodBigIntFormat>;
export interface $ZodSymbolDef extends $ZodTypeDef {
	type: "symbol";
}
export interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
	def: $ZodSymbolDef;
	isst: $ZodIssueInvalidType;
}
export interface $ZodSymbol extends $ZodType {
	_zod: $ZodSymbolInternals;
}
declare const $ZodSymbol: $constructor<$ZodSymbol>;
export interface $ZodUndefinedDef extends $ZodTypeDef {
	type: "undefined";
}
export interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
	pattern: RegExp;
	def: $ZodUndefinedDef;
	values: util.PrimitiveSet;
	isst: $ZodIssueInvalidType;
}
export interface $ZodUndefined extends $ZodType {
	_zod: $ZodUndefinedInternals;
}
declare const $ZodUndefined: $constructor<$ZodUndefined>;
export interface $ZodNullDef extends $ZodTypeDef {
	type: "null";
}
export interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
	pattern: RegExp;
	def: $ZodNullDef;
	values: util.PrimitiveSet;
	isst: $ZodIssueInvalidType;
}
export interface $ZodNull extends $ZodType {
	_zod: $ZodNullInternals;
}
declare const $ZodNull: $constructor<$ZodNull>;
export interface $ZodAnyDef extends $ZodTypeDef {
	type: "any";
}
export interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
	def: $ZodAnyDef;
	isst: never;
}
export interface $ZodAny extends $ZodType {
	_zod: $ZodAnyInternals;
}
declare const $ZodAny: $constructor<$ZodAny>;
export interface $ZodUnknownDef extends $ZodTypeDef {
	type: "unknown";
}
export interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
	def: $ZodUnknownDef;
	isst: never;
}
export interface $ZodUnknown extends $ZodType {
	_zod: $ZodUnknownInternals;
}
declare const $ZodUnknown: $constructor<$ZodUnknown>;
export interface $ZodNeverDef extends $ZodTypeDef {
	type: "never";
}
export interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
	def: $ZodNeverDef;
	isst: $ZodIssueInvalidType;
}
export interface $ZodNever extends $ZodType {
	_zod: $ZodNeverInternals;
}
declare const $ZodNever: $constructor<$ZodNever>;
export interface $ZodVoidDef extends $ZodTypeDef {
	type: "void";
}
export interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
	def: $ZodVoidDef;
	isst: $ZodIssueInvalidType;
}
export interface $ZodVoid extends $ZodType {
	_zod: $ZodVoidInternals;
}
declare const $ZodVoid: $constructor<$ZodVoid>;
export interface $ZodDateDef extends $ZodTypeDef {
	type: "date";
	coerce?: boolean;
}
export interface $ZodDateInternals<T = unknown> extends $ZodTypeInternals<Date, T> {
	def: $ZodDateDef;
	isst: $ZodIssueInvalidType;
	bag: util.LoosePartial<{
		minimum: Date;
		maximum: Date;
		format: string;
	}>;
}
export interface $ZodDate<T = unknown> extends $ZodType {
	_zod: $ZodDateInternals<T>;
}
declare const $ZodDate: $constructor<$ZodDate>;
export interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "array";
	element: T;
}
export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
	def: $ZodArrayDef<T>;
	isst: $ZodIssueInvalidType;
	output: output<T>[];
	input: input<T>[];
}
export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {
}
declare const $ZodArray: $constructor<$ZodArray>;
export type OptionalOutSchema = {
	_zod: {
		optout: "optional";
	};
};
export type OptionalInSchema = {
	_zod: {
		optin: "optional";
	};
};
export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
	-readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
} & {
	-readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
} & Extra>;
export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
	-readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
} & {
	-readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
} & Extra>;
export type $ZodObjectConfig = {
	out: Record<string, unknown>;
	in: Record<string, unknown>;
};
export type $loose = {
	out: Record<string, unknown>;
	in: Record<string, unknown>;
};
export type $strict = {
	out: {};
	in: {};
};
export type $strip = {
	out: {};
	in: {};
};
export type $catchall<T extends SomeType> = {
	out: {
		[k: string]: output<T>;
	};
	in: {
		[k: string]: input<T>;
	};
};
export type $ZodShape = Readonly<{
	[k: string]: $ZodType;
}>;
export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
	type: "object";
	shape: Shape;
	catchall?: $ZodType | undefined;
}
export interface $ZodObjectInternals<
/** @ts-ignore Cast variance */
out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
	def: $ZodObjectDef<Shape>;
	config: Config;
	isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
	propValues: util.PropValues;
	output: $InferObjectOutput<Shape, Config["out"]>;
	input: $InferObjectInput<Shape, Config["in"]>;
	optin?: "optional" | undefined;
	optout?: "optional" | undefined;
}
export type $ZodLooseShape = Record<string, any>;
export interface $ZodObject<
/** @ts-ignore Cast variance */
out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
}
declare const $ZodObject: $constructor<$ZodObject>;
declare const $ZodObjectJIT: $constructor<$ZodObject>;
export type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
export type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
	type: "union";
	options: Options;
	inclusive?: boolean;
}
export type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
export type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
	def: $ZodUnionDef<T>;
	isst: $ZodIssueInvalidUnion;
	pattern: T[number]["_zod"]["pattern"];
	values: T[number]["_zod"]["values"];
	output: $InferUnionOutput<T[number]>;
	input: $InferUnionInput<T[number]>;
	optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
	optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
}
export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
	_zod: $ZodUnionInternals<T>;
}
declare const $ZodUnion: $constructor<$ZodUnion>;
export interface $ZodXorInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<T> {
}
export interface $ZodXor<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodXorInternals<T>> {
	_zod: $ZodXorInternals<T>;
}
declare const $ZodXor: $constructor<$ZodXor>;
export interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
	discriminator: Disc;
	unionFallback?: boolean;
}
export interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
	def: $ZodDiscriminatedUnionDef<Options, Disc>;
	propValues: util.PropValues;
}
export interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
	_zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
}
declare const $ZodDiscriminatedUnion: $constructor<$ZodDiscriminatedUnion>;
export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "intersection";
	left: Left;
	right: Right;
}
export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
	def: $ZodIntersectionDef<A, B>;
	isst: never;
	optin: A["_zod"]["optin"] | B["_zod"]["optin"];
	optout: A["_zod"]["optout"] | B["_zod"]["optout"];
	output: output<A> & output<B>;
	input: input<A> & input<B>;
}
export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodIntersectionInternals<A, B>;
}
declare const $ZodIntersection: $constructor<$ZodIntersection>;
export interface $ZodTupleDef<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
	type: "tuple";
	items: T;
	rest: Rest;
}
export type $InferTupleInputType<T extends util.TupleItems, Rest extends SomeType | null> = [
	...TupleInputTypeWithOptionals<T>,
	...(Rest extends SomeType ? input<Rest>[] : [
	])
];
export type TupleInputTypeNoOptionals<T extends util.TupleItems> = {
	[k in keyof T]: input<T[k]>;
};
export type TupleInputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
	...infer Prefix extends SomeType[],
	infer Tail extends SomeType
] ? Tail["_zod"]["optin"] extends "optional" ? [
	...TupleInputTypeWithOptionals<Prefix>,
	input<Tail>?
] : TupleInputTypeNoOptionals<T> : [
];
export type $InferTupleOutputType<T extends util.TupleItems, Rest extends SomeType | null> = [
	...TupleOutputTypeWithOptionals<T>,
	...(Rest extends SomeType ? output<Rest>[] : [
	])
];
export type TupleOutputTypeNoOptionals<T extends util.TupleItems> = {
	[k in keyof T]: output<T[k]>;
};
export type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
	...infer Prefix extends SomeType[],
	infer Tail extends SomeType
] ? Tail["_zod"]["optout"] extends "optional" ? [
	...TupleOutputTypeWithOptionals<Prefix>,
	output<Tail>?
] : TupleOutputTypeNoOptionals<T> : [
];
export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
	def: $ZodTupleDef<T, Rest>;
	isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
	output: $InferTupleOutputType<T, Rest>;
	input: $InferTupleInputType<T, Rest>;
}
export interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
	_zod: $ZodTupleInternals<T, Rest>;
}
declare const $ZodTuple: $constructor<$ZodTuple>;
export type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
export interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "record";
	keyType: Key;
	valueType: Value;
	/** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
	mode?: "strict" | "loose";
}
export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key> & PropertyKey, input<Value>>> : Record<input<Key> & PropertyKey, input<Value>>;
export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
	def: $ZodRecordDef<Key, Value>;
	isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
	optin?: "optional" | undefined;
	optout?: "optional" | undefined;
}
export type $partial = {
	"~~partial": true;
};
export interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodRecordInternals<Key, Value>;
}
declare const $ZodRecord: $constructor<$ZodRecord>;
export interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "map";
	keyType: Key;
	valueType: Value;
}
export interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key>, output<Value>>, Map<input<Key>, input<Value>>> {
	def: $ZodMapDef<Key, Value>;
	isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
	optin?: "optional" | undefined;
	optout?: "optional" | undefined;
}
export interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodMapInternals<Key, Value>;
}
declare const $ZodMap: $constructor<$ZodMap>;
export interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "set";
	valueType: T;
}
export interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T>>, Set<input<T>>> {
	def: $ZodSetDef<T>;
	isst: $ZodIssueInvalidType;
	optin?: "optional" | undefined;
	optout?: "optional" | undefined;
}
export interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodSetInternals<T>;
}
declare const $ZodSet: $constructor<$ZodSet>;
export type $InferEnumOutput<T extends util.EnumLike> = T[keyof T] & {};
export type $InferEnumInput<T extends util.EnumLike> = T[keyof T] & {};
export interface $ZodEnumDef<T extends util.EnumLike = util.EnumLike> extends $ZodTypeDef {
	type: "enum";
	entries: T;
}
export interface $ZodEnumInternals<
/** @ts-ignore Cast variance */
out T extends util.EnumLike = util.EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
	def: $ZodEnumDef<T>;
	/** @deprecated Internal API, use with caution (not deprecated) */
	values: util.PrimitiveSet;
	/** @deprecated Internal API, use with caution (not deprecated) */
	pattern: RegExp;
	isst: $ZodIssueInvalidValue;
}
export interface $ZodEnum<T extends util.EnumLike = util.EnumLike> extends $ZodType {
	_zod: $ZodEnumInternals<T>;
}
declare const $ZodEnum: $constructor<$ZodEnum>;
export interface $ZodLiteralDef<T extends util.Literal> extends $ZodTypeDef {
	type: "literal";
	values: T[];
}
export interface $ZodLiteralInternals<T extends util.Literal = util.Literal> extends $ZodTypeInternals<T, T> {
	def: $ZodLiteralDef<T>;
	values: Set<T>;
	pattern: RegExp;
	isst: $ZodIssueInvalidValue;
}
export interface $ZodLiteral<T extends util.Literal = util.Literal> extends $ZodType {
	_zod: $ZodLiteralInternals<T>;
}
declare const $ZodLiteral: $constructor<$ZodLiteral>;
type _File$1 = typeof globalThis extends {
	File: infer F extends new (...args: any[]) => any;
} ? InstanceType<F> : {};
interface File$1 extends _File$1 {
	readonly type: string;
	readonly size: number;
}
export interface $ZodFileDef extends $ZodTypeDef {
	type: "file";
}
export interface $ZodFileInternals extends $ZodTypeInternals<File$1, File$1> {
	def: $ZodFileDef;
	isst: $ZodIssueInvalidType;
	bag: util.LoosePartial<{
		minimum: number;
		maximum: number;
		mime: util.MimeTypes[];
	}>;
}
export interface $ZodFile extends $ZodType {
	_zod: $ZodFileInternals;
}
declare const $ZodFile: $constructor<$ZodFile>;
export interface $ZodTransformDef extends $ZodTypeDef {
	type: "transform";
	transform: (input: unknown, payload: ParsePayload<unknown>) => util.MaybeAsync<unknown>;
}
export interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
	def: $ZodTransformDef;
	isst: never;
}
export interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
	_zod: $ZodTransformInternals<O, I>;
}
declare const $ZodTransform: $constructor<$ZodTransform>;
export interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "optional";
	innerType: T;
}
export 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"];
}
export interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodOptionalInternals<T>;
}
declare const $ZodOptional: $constructor<$ZodOptional>;
export interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {
}
export interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
	def: $ZodExactOptionalDef<T>;
	output: output<T>;
	input: input<T>;
}
export interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodExactOptionalInternals<T>;
}
declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
export interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "nullable";
	innerType: T;
}
export 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"];
}
export interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodNullableInternals<T>;
}
declare const $ZodNullable: $constructor<$ZodNullable>;
export interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "default";
	innerType: T;
	/** The default value. May be a getter. */
	defaultValue: util.NoUndefined<output<T>>;
}
export interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<output<T>>, input<T> | undefined> {
	def: $ZodDefaultDef<T>;
	optin: "optional";
	optout?: "optional" | undefined;
	isst: never;
	values: T["_zod"]["values"];
}
export interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodDefaultInternals<T>;
}
declare const $ZodDefault: $constructor<$ZodDefault>;
export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "prefault";
	innerType: T;
	/** The default value. May be a getter. */
	defaultValue: input<T>;
}
export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<output<T>>, input<T> | undefined> {
	def: $ZodPrefaultDef<T>;
	optin: "optional";
	optout?: "optional" | undefined;
	isst: never;
	values: T["_zod"]["values"];
}
export interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodPrefaultInternals<T>;
}
declare const $ZodPrefault: $constructor<$ZodPrefault>;
export interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "nonoptional";
	innerType: T;
}
export interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<output<T>>, util.NoUndefined<input<T>>> {
	def: $ZodNonOptionalDef<T>;
	isst: $ZodIssueInvalidType;
	values: T["_zod"]["values"];
	optin: "optional" | undefined;
	optout: "optional" | undefined;
}
export interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodNonOptionalInternals<T>;
}
declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
export interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "success";
	innerType: T;
}
export interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T>> {
	def: $ZodSuccessDef<T>;
	isst: never;
	optin: T["_zod"]["optin"];
	optout: "optional" | undefined;
}
export interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodSuccessInternals<T>;
}
declare const $ZodSuccess: $constructor<$ZodSuccess>;
export interface $ZodCatchCtx extends ParsePayload {
	/** @deprecated Use `ctx.issues` */
	error: {
		issues: $ZodIssue[];
	};
	/** @deprecated Use `ctx.value` */
	input: unknown;
}
export interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "catch";
	innerType: T;
	catchValue: (ctx: $ZodCatchCtx) => unknown;
}
export interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
	def: $ZodCatchDef<T>;
	optin: T["_zod"]["optin"];
	optout: T["_zod"]["optout"];
	isst: never;
	values: T["_zod"]["values"];
}
export interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodCatchInternals<T>;
}
declare const $ZodCatch: $constructor<$ZodCatch>;
export interface $ZodNaNDef extends $ZodTypeDef {
	type: "nan";
}
export interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
	def: $ZodNaNDef;
	isst: $ZodIssueInvalidType;
}
export interface $ZodNaN extends $ZodType {
	_zod: $ZodNaNInternals;
}
declare const $ZodNaN: $constructor<$ZodNaN>;
export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "pipe";
	in: A;
	out: B;
	/** Only defined inside $ZodCodec instances. */
	transform?: (value: output<A>, payload: ParsePayload<output<A>>) => util.MaybeAsync<input<B>>;
	/** Only defined inside $ZodCodec instances. */
	reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => util.MaybeAsync<output<A>>;
}
export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
	def: $ZodPipeDef<A, B>;
	isst: never;
	values: A["_zod"]["values"];
	optin: A["_zod"]["optin"];
	optout: B["_zod"]["optout"];
	propValues: A["_zod"]["propValues"];
}
export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodPipeInternals<A, B>;
}
declare const $ZodPipe: $constructor<$ZodPipe>;
export interface $ZodCodecDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodPipeDef<A, B> {
	transform: (value: output<A>, payload: ParsePayload<output<A>>) => util.MaybeAsync<input<B>>;
	reverseTransform: (value: input<B>, payload: ParsePayload<input<B>>) => util.MaybeAsync<output<A>>;
}
export interface $ZodCodecInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
	def: $ZodCodecDef<A, B>;
	isst: never;
	values: A["_zod"]["values"];
	optin: A["_zod"]["optin"];
	optout: B["_zod"]["optout"];
	propValues: A["_zod"]["propValues"];
}
export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodCodecInternals<A, B>;
}
declare const $ZodCodec: $constructor<$ZodCodec>;
export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "readonly";
	innerType: T;
}
export interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.MakeReadonly<output<T>>, util.MakeReadonly<input<T>>> {
	def: $ZodReadonlyDef<T>;
	optin: T["_zod"]["optin"];
	optout: T["_zod"]["optout"];
	isst: never;
	propValues: T["_zod"]["propValues"];
	values: T["_zod"]["values"];
}
export interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodReadonlyInternals<T>;
}
declare const $ZodReadonly: $constructor<$ZodReadonly>;
export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
	type: "template_literal";
	parts: $ZodTemplateLiteralPart[];
	format?: string | undefined;
}
export interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
	pattern: RegExp;
	def: $ZodTemplateLiteralDef;
	isst: $ZodIssueInvalidType;
}
export interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
	_zod: $ZodTemplateLiteralInternals<Template>;
}
export type LiteralPart = Exclude<util.Literal, symbol>;
export interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
	pattern: RegExp;
}
export interface SchemaPart extends $ZodType {
	_zod: SchemaPartInternals;
}
export type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
export type UndefinedToEmptyString<T> = T extends undefined ? "" : T;
export type AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $ZodType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : Suffix extends $ZodType ? `${Template}${output<Suffix> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
export type ConcatenateTupleOfStrings<T extends string[]> = T extends [
	infer First extends string,
	...infer Rest extends string[]
] ? Rest extends string[] ? First extends "" ? ConcatenateTupleOfStrings<Rest> : `${First}${ConcatenateTupleOfStrings<Rest>}` : never : "";
export type ConvertPartsToStringTuple<Parts extends $ZodTemplateLiteralPart[]> = {
	[K in keyof Parts]: Parts[K] extends LiteralPart ? `${UndefinedToEmptyString<Parts[K]>}` : Parts[K] extends $ZodType ? `${output<Parts[K]> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
};
export type ToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = ConcatenateTupleOfStrings<ConvertPartsToStringTuple<Parts>>;
export type $PartsToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = [
] extends Parts ? `` : Parts extends [
	...infer Rest,
	infer Last extends $ZodTemplateLiteralPart
] ? Rest extends $ZodTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;
declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
export type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
export type $ZodFunctionIn = $ZodFunctionArgs;
export type $ZodFunctionOut = $ZodType;
export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => util.MaybeAsync<input<Returns>>;
export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => Promise<output<Returns>>;
export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
	type: "function";
	input: In;
	output: Out;
}
export interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
	def: $ZodFunctionDef<Args, Returns>;
	isst: $ZodIssueInvalidType;
}
export interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
	/** @deprecated */
	_def: $ZodFunctionDef<Args, Returns>;
	_input: $InferInnerFunctionType<Args, Returns>;
	_output: $InferOuterFunctionType<Args, Returns>;
	implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
	implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
	input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
	input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
	input(...args: any[]): $ZodFunction<any, Returns>;
	output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
}
export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends $ZodType> {
	input?: I;
	output?: O;
}
declare const $ZodFunction: $constructor<$ZodFunction>;
export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "promise";
	innerType: T;
}
export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T>>, util.MaybeAsync<input<T>>> {
	def: $ZodPromiseDef<T>;
	isst: never;
}
export interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodPromiseInternals<T>;
}
declare const $ZodPromise: $constructor<$ZodPromise>;
export interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
	type: "lazy";
	getter: () => T;
}
export interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
	def: $ZodLazyDef<T>;
	isst: never;
	/** Auto-cached way to retrieve the inner schema */
	innerType: T;
	pattern: T["_zod"]["pattern"];
	propValues: T["_zod"]["propValues"];
	optin: T["_zod"]["optin"];
	optout: T["_zod"]["optout"];
}
export interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
	_zod: $ZodLazyInternals<T>;
}
declare const $ZodLazy: $constructor<$ZodLazy>;
export 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;
}
export interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
	def: $ZodCustomDef;
	issc: $ZodIssue;
	isst: never;
	bag: util.LoosePartial<{
		Class: typeof util.Class;
	}>;
}
export interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
	_zod: $ZodCustomInternals<O, I>;
}
declare const $ZodCustom: $constructor<$ZodCustom>;
export type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname">;
export 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;
	/** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
	when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
}
export interface $ZodCheckInternals<T> {
	def: $ZodCheckDef;
	/** The set of issues this check might throw. */
	issc?: $ZodIssueBase;
	check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
	onattach: ((schema: schemas.$ZodType) => void)[];
}
export interface $ZodCheck<in T = never> {
	_zod: $ZodCheckInternals<T>;
}
declare const $ZodCheck: $constructor<$ZodCheck<any>>;
export interface $ZodCheckLessThanDef extends $ZodCheckDef {
	check: "less_than";
	value: util.Numeric;
	inclusive: boolean;
}
export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
	def: $ZodCheckLessThanDef;
	issc: $ZodIssueTooBig<T>;
}
export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
	_zod: $ZodCheckLessThanInternals<T>;
}
declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
export interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
	check: "greater_than";
	value: util.Numeric;
	inclusive: boolean;
}
export interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
	def: $ZodCheckGreaterThanDef;
	issc: $ZodIssueTooSmall<T>;
}
export interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
	_zod: $ZodCheckGreaterThanInternals<T>;
}
declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
export interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
	check: "multiple_of";
	value: T;
}
export interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
	def: $ZodCheckMultipleOfDef<T>;
	issc: $ZodIssueNotMultipleOf;
}
export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
	_zod: $ZodCheckMultipleOfInternals<T>;
}
declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
export interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
	check: "number_format";
	format: $ZodNumberFormats;
}
export interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
	def: $ZodCheckNumberFormatDef;
	issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
}
export interface $ZodCheckNumberFormat extends $ZodCheck<number> {
	_zod: $ZodCheckNumberFormatInternals;
}
declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
export type $ZodBigIntFormats = "int64" | "uint64";
export interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {
	check: "bigint_format";
	format: $ZodBigIntFormats | undefined;
}
export interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {
	def: $ZodCheckBigIntFormatDef;
	issc: $ZodIssueTooBig<"bigint"> | $ZodIssueTooSmall<"bigint">;
}
export interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {
	_zod: $ZodCheckBigIntFormatInternals;
}
declare const $ZodCheckBigIntFormat: $constructor<$ZodCheckBigIntFormat>;
export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
	check: "max_size";
	maximum: number;
}
export interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
	def: $ZodCheckMaxSizeDef;
	issc: $ZodIssueTooBig<T>;
}
export interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
	_zod: $ZodCheckMaxSizeInternals<T>;
}
declare const $ZodCheckMaxSize: $constructor<$ZodCheckMaxSize>;
export interface $ZodCheckMinSizeDef extends $ZodCheckDef {
	check: "min_size";
	minimum: number;
}
export interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
	def: $ZodCheckMinSizeDef;
	issc: $ZodIssueTooSmall<T>;
}
export interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
	_zod: $ZodCheckMinSizeInternals<T>;
}
declare const $ZodCheckMinSize: $constructor<$ZodCheckMinSize>;
export interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
	check: "size_equals";
	size: number;
}
export interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
	def: $ZodCheckSizeEqualsDef;
	issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
}
export interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
	_zod: $ZodCheckSizeEqualsInternals<T>;
}
declare const $ZodCheckSizeEquals: $constructor<$ZodCheckSizeEquals>;
export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
	check: "max_length";
	maximum: number;
}
export interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
	def: $ZodCheckMaxLengthDef;
	issc: $ZodIssueTooBig<T>;
}
export interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
	_zod: $ZodCheckMaxLengthInternals<T>;
}
declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
	check: "min_length";
	minimum: number;
}
export interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
	def: $ZodCheckMinLengthDef;
	issc: $ZodIssueTooSmall<T>;
}
export interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
	_zod: $ZodCheckMinLengthInternals<T>;
}
declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
	check: "length_equals";
	length: number;
}
export interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
	def: $ZodCheckLengthEqualsDef;
	issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
}
export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
	_zod: $ZodCheckLengthEqualsInternals<T>;
}
declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
export 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";
export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
	check: "string_format";
	format: Format;
	pattern?: RegExp | undefined;
}
export interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
	def: $ZodCheckStringFormatDef;
	issc: $ZodIssueInvalidStringFormat;
}
export interface $ZodCheckStringFormat extends $ZodCheck<string> {
	_zod: $ZodCheckStringFormatInternals;
}
declare const $ZodCheckStringFormat: $constructor<$ZodCheckStringFormat>;
export interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
	format: "regex";
	pattern: RegExp;
}
export interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
	def: $ZodCheckRegexDef;
	issc: $ZodIssueInvalidStringFormat;
}
export interface $ZodCheckRegex extends $ZodCheck<string> {
	_zod: $ZodCheckRegexInternals;
}
declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
export interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
}
export interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
	def: $ZodCheckLowerCaseDef;
	issc: $ZodIssueInvalidStringFormat;
}
export interface $ZodCheckLowerCase extends $ZodCheck<string> {
	_zod: $ZodCheckLowerCaseInternals;
}
declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
export interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
}
export interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
	def: $ZodCheckUpperCaseDef;
	issc: $ZodIssueInvalidStringFormat;
}
export interface $ZodCheckUpperCase extends $ZodCheck<string> {
	_zod: $ZodCheckUpperCaseInternals;
}
declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
export interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
	includes: string;
	position?: number | undefined;
}
export interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
	def: $ZodCheckIncludesDef;
	issc: $ZodIssueInvalidStringFormat;
}
export interface $ZodCheckIncludes extends $ZodCheck<string> {
	_zod: $ZodCheckIncludesInternals;
}
declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
export interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
	prefix: string;
}
export interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
	def: $ZodCheckStartsWithDef;
	issc: $ZodIssueInvalidStringFormat;
}
export interface $ZodCheckStartsWith extends $ZodCheck<string> {
	_zod: $ZodCheckStartsWithInternals;
}
declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
export interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
	suffix: string;
}
export interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
	def: $ZodCheckEndsWithDef;
	issc: $ZodIssueInvalidStringFormat;
}
export interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
	_zod: $ZodCheckEndsWithInternals;
}
declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
export interface $ZodCheckPropertyDef extends $ZodCheckDef {
	check: "property";
	property: string;
	schema: schemas.$ZodType;
}
export interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
	def: $ZodCheckPropertyDef;
	issc: $ZodIssue;
}
export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
	_zod: $ZodCheckPropertyInternals<T>;
}
declare const $ZodCheckProperty: $constructor<$ZodCheckProperty>;
export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
	check: "mime_type";
	mime: util.MimeTypes[];
}
export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
	def: $ZodCheckMimeTypeDef;
	issc: $ZodIssueInvalidValue;
}
export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
	_zod: $ZodCheckMimeTypeInternals<T>;
}
declare const $ZodCheckMimeType: $constructor<$ZodCheckMimeType>;
export interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
	check: "overwrite";
	tx(value: T): T;
}
export interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
	def: $ZodCheckOverwriteDef<T>;
	issc: never;
}
export interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
	_zod: $ZodCheckOverwriteInternals<T>;
}
declare const $ZodCheckOverwrite: $constructor<$ZodCheckOverwrite>;
export type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
export type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;
export interface $ZodIssueBase {
	readonly code?: string;
	readonly input?: unknown;
	readonly path: PropertyKey[];
	readonly message: string;
}
export type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
	readonly code: "invalid_type";
	readonly expected: $ZodInvalidTypeExpected;
	readonly input?: Input;
}
export 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 exact?: boolean;
	readonly input?: Input;
}
export 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;
	/** True if the allowable range includes the minimum */
	readonly inclusive?: boolean;
	/** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
	readonly exact?: boolean;
	readonly input?: Input;
}
export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
	readonly code: "invalid_format";
	readonly format: $ZodStringFormats | (string & {});
	readonly pattern?: string;
	readonly input?: string;
}
export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
	readonly code: "not_multiple_of";
	readonly divisor: number;
	readonly input?: Input;
}
export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
	readonly code: "unrecognized_keys";
	readonly keys: string[];
	readonly input?: Record<string, unknown>;
}
export interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
	readonly code: "invalid_union";
	readonly errors: $ZodIssue[][];
	readonly input?: unknown;
	readonly discriminator?: string | undefined;
	readonly inclusive?: true;
}
export interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
	readonly code: "invalid_union";
	readonly errors: [
	];
	readonly input?: unknown;
	readonly discriminator?: string | undefined;
	readonly inclusive: false;
}
export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
	readonly code: "invalid_key";
	readonly origin: "map" | "record";
	readonly issues: $ZodIssue[];
	readonly input?: Input;
}
export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
	readonly code: "invalid_element";
	readonly origin: "map" | "set";
	readonly key: unknown;
	readonly issues: $ZodIssue[];
	readonly input?: Input;
}
export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
	readonly code: "invalid_value";
	readonly values: util.Primitive[];
	readonly input?: Input;
}
export interface $ZodIssueCustom extends $ZodIssueBase {
	readonly code: "custom";
	readonly params?: Record<string, any> | undefined;
	readonly input?: unknown;
}
export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
	format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
}
export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
	format: "regex";
	pattern: string;
}
export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
	format: "jwt";
	algorithm?: string;
}
export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
	format: "starts_with";
	prefix: string;
}
export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
	format: "ends_with";
	suffix: string;
}
export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
	format: "includes";
	includes: string;
}
export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
export type $ZodIssueCode = $ZodIssue["code"];
export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
export type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
	/** The input data */
	readonly input: unknown;
	/** The schema or check that originated this issue. */
	readonly inst?: $ZodType | $ZodCheck;
	/** If `true`, Zod will continue executing checks/refinements after this issue. */
	readonly continue?: boolean | undefined;
} & Record<string, unknown>> : never;
export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
	(issue: $ZodRawIssue<T>): {
		message: string;
	} | string | undefined | null;
}
export interface $ZodError<T = unknown> extends Error {
	type: T;
	issues: $ZodIssue[];
	_zod: {
		output: T;
		def: $ZodIssue[];
	};
	stack?: string;
	name: string;
}
declare const $ZodError: $constructor<$ZodError>;
export interface $ZodRealError<T = any> extends $ZodError<T> {
}
declare const $ZodRealError$1: $constructor<$ZodRealError>;
export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
export type _FlattenedError<T, U = string> = {
	formErrors: U[];
	fieldErrors: {
		[P in keyof T]?: U[];
	};
};
declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
export 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 ? util.Flatten<{
	[K in keyof T]?: $ZodFormattedError<T[K], U>;
}> : any;
export type $ZodFormattedError<T, U = string> = {
	_errors: U[];
} & util.Flatten<_ZodFormattedError<T, U>>;
declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
	errors: U[];
} : T extends [
	any,
	...any[]
] ? {
	errors: U[];
	items?: {
		[K in keyof T]?: $ZodErrorTree<T[K], U>;
	};
} : T extends any[] ? {
	errors: U[];
	items?: Array<$ZodErrorTree<T[number], U>>;
} : T extends object ? {
	errors: U[];
	properties?: {
		[K in keyof T]?: $ZodErrorTree<T[K], U>;
	};
} : {
	errors: U[];
};
declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
export type ZodTrait = {
	_zod: {
		def: any;
		[k: string]: any;
	};
};
export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
	new (def: D): T;
	init(inst: T, def: D): asserts inst is T;
}
declare const NEVER: never;
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;
export type $brand<T extends string | number | symbol = string | number | symbol> = {
	[$brand]: {
		[k in T]: true;
	};
};
export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
	_zod: {
		input: input<T> & $brand<Brand>;
		output: output<T> & $brand<Brand>;
	};
} : Dir extends "in" ? {
	_zod: {
		input: input<T> & $brand<Brand>;
	};
} : {
	_zod: {
		output: output<T> & $brand<Brand>;
	};
});
export type $ZodNarrow<T extends schemas.SomeType, Out> = T & {
	_zod: {
		output: Out;
	};
};
declare class $ZodAsyncError extends Error {
	constructor();
}
declare class $ZodEncodeError extends Error {
	constructor(name: string);
}
export type input<T> = T extends {
	_zod: {
		input: any;
	};
} ? T["_zod"]["input"] : unknown;
export type output<T> = T extends {
	_zod: {
		output: any;
	};
} ? T["_zod"]["output"] : unknown;
export interface $ZodConfig {
	/** Custom error map. Overrides `config().localeError`. */
	customError?: $ZodErrorMap | undefined;
	/** Localized error map. Lowest priority. */
	localeError?: $ZodErrorMap | undefined;
	/** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
	jitless?: boolean | undefined;
}
declare const globalConfig: $ZodConfig;
declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;
export type $ZodErrorClass = {
	new (issues: $ZodIssue[]): $ZodError;
};
export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<$ZodIssue>, _params?: {
	callee?: util.AnyFunc;
	Err?: $ZodErrorClass;
}) => output<T>;
declare const _parse: (_Err: $ZodErrorClass) => $Parse;
declare const parse: $Parse;
export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<$ZodIssue>, _params?: {
	callee?: util.AnyFunc;
	Err?: $ZodErrorClass;
}) => Promise<output<T>>;
declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
declare const parseAsync: $ParseAsync;
export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<$ZodIssue>) => util.SafeParseResult<output<T>>;
declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
declare const safeParse: $SafeParse;
export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<$ZodIssue>) => Promise<util.SafeParseResult<output<T>>>;
declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
declare const safeParseAsync: $SafeParseAsync;
export type $Encode = <T extends schemas.$ZodType>(schema: T, value: output<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => input<T>;
declare const _encode: (_Err: $ZodErrorClass) => $Encode;
declare const encode: $Encode;
export type $Decode = <T extends schemas.$ZodType>(schema: T, value: input<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => output<T>;
declare const _decode: (_Err: $ZodErrorClass) => $Decode;
declare const decode: $Decode;
export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: output<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => Promise<input<T>>;
declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
declare const encodeAsync: $EncodeAsync;
export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: input<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => Promise<output<T>>;
declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
declare const decodeAsync: $DecodeAsync;
export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: output<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => util.SafeParseResult<input<T>>;
declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
declare const safeEncode: $SafeEncode;
export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: input<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => util.SafeParseResult<output<T>>;
declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
declare const safeDecode: $SafeDecode;
export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: output<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => Promise<util.SafeParseResult<input<T>>>;
declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
declare const safeEncodeAsync: $SafeEncodeAsync;
export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: input<T>, _ctx?: schemas.ParseContext<$ZodIssue>) => Promise<util.SafeParseResult<output<T>>>;
declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
declare const safeDecodeAsync: $SafeDecodeAsync;
declare const cuid: RegExp;
declare const cuid2: RegExp;
declare const ulid: RegExp;
declare const xid: RegExp;
declare const ksuid: RegExp;
declare const nanoid: RegExp;
declare const duration: RegExp;
declare const extendedDuration: RegExp;
declare const guid: RegExp;
declare const uuid: (version?: number | undefined) => RegExp;
declare const uuid4: RegExp;
declare const uuid6: RegExp;
declare const uuid7: RegExp;
declare const email: RegExp;
declare const html5Email: RegExp;
declare const rfc5322Email: RegExp;
declare const unicodeEmail: RegExp;
declare const idnEmail: RegExp;
declare const browserEmail: RegExp;
declare function emoji(): RegExp;
declare const ipv4: RegExp;
declare const ipv6: RegExp;
declare const mac: (delimiter?: string) => RegExp;
declare const cidrv4: RegExp;
declare const cidrv6: RegExp;
declare const base64: RegExp;
declare const base64url: RegExp;
declare const hostname: RegExp;
declare const domain: RegExp;
declare const e164: RegExp;
declare const date: RegExp;
declare function time(args: {
	precision?: number | null;
}): RegExp;
declare function datetime(args: {
	precision?: number | null;
	offset?: boolean;
	local?: boolean;
}): RegExp;
declare const string: (params?: {
	minimum?: number | undefined;
	maximum?: number | undefined;
}) => RegExp;
declare const bigint: RegExp;
declare const integer: RegExp;
declare const number: RegExp;
declare const boolean: RegExp;
declare const _null: RegExp;
declare const _undefined: RegExp;
declare const lowercase: RegExp;
declare const uppercase: RegExp;
declare const hex: RegExp;
declare const md5_hex: RegExp;
declare const md5_base64: RegExp;
declare const md5_base64url: RegExp;
declare const sha1_hex: RegExp;
declare const sha1_base64: RegExp;
declare const sha1_base64url: RegExp;
declare const sha256_hex: RegExp;
declare const sha256_base64: RegExp;
declare const sha256_base64url: RegExp;
declare const sha384_hex: RegExp;
declare const sha384_base64: RegExp;
declare const sha384_base64url: RegExp;
declare const sha512_hex: RegExp;
declare const sha512_base64: RegExp;
declare const sha512_base64url: RegExp;
declare function _default(): {
	localeError: $ZodErrorMap;
};
declare function _default$1(): {
	localeError: $ZodErrorMap;
};
declare function _default$2(): {
	localeError: $ZodErrorMap;
};
declare function _default$3(): {
	localeError: $ZodErrorMap;
};
declare function _default$4(): {
	localeError: $ZodErrorMap;
};
declare function _default$5(): {
	localeError: $ZodErrorMap;
};
declare function _default$6(): {
	localeError: $ZodErrorMap;
};
declare function _default$7(): {
	localeError: $ZodErrorMap;
};
declare function _default$8(): {
	localeError: $ZodErrorMap;
};
declare function _default$9(): {
	localeError: $ZodErrorMap;
};
declare function _default$10(): {
	localeError: $ZodErrorMap;
};
declare function _default$11(): {
	localeError: $ZodErrorMap;
};
declare function _default$12(): {
	localeError: $ZodErrorMap;
};
declare function _default$13(): {
	localeError: $ZodErrorMap;
};
declare function _default$14(): {
	localeError: $ZodErrorMap;
};
declare function _default$15(): {
	localeError: $ZodErrorMap;
};
declare function _default$16(): {
	localeError: $ZodErrorMap;
};
declare function _default$17(): {
	localeError: $ZodErrorMap;
};
declare function _default$18(): {
	localeError: $ZodErrorMap;
};
declare function _default$19(): {
	localeError: $ZodErrorMap;
};
declare function _default$20(): {
	localeError: $ZodErrorMap;
};
declare function _default$21(): {
	localeError: $ZodErrorMap;
};
declare function _default$22(): {
	localeError: $ZodErrorMap;
};
declare function _default$23(): {
	localeError: $ZodErrorMap;
};
declare function _default$24(): {
	localeError: $ZodErrorMap;
};
declare function _default$25(): {
	localeError: $ZodErrorMap;
};
declare function _default$26(): {
	localeError: $ZodErrorMap;
};
declare function _default$27(): {
	localeError: $ZodErrorMap;
};
declare function _default$28(): {
	localeError: $ZodErrorMap;
};
declare function _default$29(): {
	localeError: $ZodErrorMap;
};
declare function _default$30(): {
	localeError: $ZodErrorMap;
};
declare function _default$31(): {
	localeError: $ZodErrorMap;
};
declare function _default$32(): {
	localeError: $ZodErrorMap;
};
declare function _default$33(): {
	localeError: $ZodErrorMap;
};
declare function _default$34(): {
	localeError: $ZodErrorMap;
};
declare function _default$35(): {
	localeError: $ZodErrorMap;
};
declare function _default$36(): {
	localeError: $ZodErrorMap;
};
declare function _default$37(): {
	localeError: $ZodErrorMap;
};
declare function _default$38(): {
	localeError: $ZodErrorMap;
};
declare function _default$39(): {
	localeError: $ZodErrorMap;
};
declare function _default$40(): {
	localeError: $ZodErrorMap;
};
declare function _default$41(): {
	localeError: $ZodErrorMap;
};
declare function _default$42(): {
	localeError: $ZodErrorMap;
};
declare function _default$43(): {
	localeError: $ZodErrorMap;
};
declare function _default$44(): {
	localeError: $ZodErrorMap;
};
declare function _default$45(): {
	localeError: $ZodErrorMap;
};
declare function _default$46(): {
	localeError: $ZodErrorMap;
};
declare function _default$47(): {
	localeError: $ZodErrorMap;
};
declare function _default$48(): {
	localeError: $ZodErrorMap;
};
export type ModeWriter = (doc: Doc, modes: {
	execution: "sync" | "async";
}) => void;
declare class Doc {
	args: string[];
	content: string[];
	indent: number;
	constructor(args?: string[]);
	indented(fn: (doc: Doc) => void): void;
	write(fn: ModeWriter): void;
	write(line: string): void;
	compile(): any;
}
export type Params<T extends schemas.$ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = util.Flatten<Partial<util.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;
})>>>;
export type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {
	_isst: never;
}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
export 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>;
export type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
export type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$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>;
export type CheckTypeParams<T extends schemas.$ZodType & $ZodCheck = schemas.$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>;
export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
export type $ZodCheckStringFormatParams = CheckParams<$ZodCheckStringFormat, "format">;
export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when">;
export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when">;
declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
export type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
export type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;
export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
declare const TimePrecision: {
	readonly Any: null;
	readonly Minute: -1;
	readonly Second: 0;
	readonly Millisecond: 3;
	readonly Microsecond: 6;
};
export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
export type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
export type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, "coerce">;
declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
export type $ZodCheckBigIntFormatParams = CheckParams<$ZodCheckBigIntFormat, "format" | "when">;
declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
export type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;
declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;
export type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;
declare function _undefined$1<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;
export type $ZodNullParams = TypeParams<schemas.$ZodNull>;
declare function _null$1<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;
export type $ZodAnyParams = TypeParams<schemas.$ZodAny>;
declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;
export type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;
declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;
export type $ZodNeverParams = TypeParams<schemas.$ZodNever>;
declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;
export type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;
declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;
export type $ZodDateParams = TypeParams<schemas.$ZodDate, "coerce">;
declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
export type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan<util.Numeric>;
declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan<util.Numeric>;
export type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
declare function _positive(params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
declare function _negative(params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan;
declare function _nonpositive(params?: string | $ZodCheckLessThanParams): $ZodCheckLessThan;
declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): $ZodCheckGreaterThan;
export type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): $ZodCheckMultipleOf;
export type $ZodCheckMaxSizeParams = CheckParams<$ZodCheckMaxSize, "maximum" | "when">;
declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): $ZodCheckMaxSize<util.HasSize>;
export type $ZodCheckMinSizeParams = CheckParams<$ZodCheckMinSize, "minimum" | "when">;
declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): $ZodCheckMinSize<util.HasSize>;
export type $ZodCheckSizeEqualsParams = CheckParams<$ZodCheckSizeEquals, "size" | "when">;
declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): $ZodCheckSizeEquals<util.HasSize>;
export type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): $ZodCheckMaxLength<util.HasLength>;
export type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): $ZodCheckMinLength<util.HasLength>;
export type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): $ZodCheckLengthEquals<util.HasLength>;
export type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): $ZodCheckRegex;
export type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): $ZodCheckLowerCase;
export type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): $ZodCheckUpperCase;
export type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): $ZodCheckIncludes;
export type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): $ZodCheckStartsWith;
export type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): $ZodCheckEndsWith;
export type $ZodCheckPropertyParams = CheckParams<$ZodCheckProperty, "property" | "schema" | "when">;
declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): $ZodCheckProperty<{
	[k in K]: output<T>;
}>;
export type $ZodCheckMimeTypeParams = CheckParams<$ZodCheckMimeType, "mime" | "when">;
declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): $ZodCheckMimeType;
declare function _overwrite<T>(tx: (input: T) => T): $ZodCheckOverwrite<T>;
declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): $ZodCheckOverwrite<string>;
declare function _trim(): $ZodCheckOverwrite<string>;
declare function _toLowerCase(): $ZodCheckOverwrite<string>;
declare function _toUpperCase(): $ZodCheckOverwrite<string>;
declare function _slugify(): $ZodCheckOverwrite<string>;
export type $ZodArrayParams = TypeParams<schemas.$ZodArray, "element">;
declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;
export type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchall">;
export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
	propValues: util.PropValues;
}
export interface $ZodTypeDiscriminable extends schemas.$ZodType {
	_zod: $ZodTypeDiscriminableInternals;
}
export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
declare function _discriminatedUnion<Types extends [
	$ZodTypeDiscriminable,
	...$ZodTypeDiscriminable[]
], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
declare function _tuple<T extends readonly [
	schemas.$ZodType,
	...schemas.$ZodType[]
]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;
declare function _tuple<T extends readonly [
	schemas.$ZodType,
	...schemas.$ZodType[]
], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;
export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType">;
declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;
export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;
export type $ZodSetParams = TypeParams<schemas.$ZodSet, "valueType">;
declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;
export type $ZodEnumParams = TypeParams<schemas.$ZodEnum, "entries">;
declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;
declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
export type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, "values">;
declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;
declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;
export type $ZodFileParams = TypeParams<schemas.$ZodFile>;
declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;
export type $ZodTransformParams = TypeParams<schemas.$ZodTransform, "transform">;
declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;
export type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, "innerType">;
declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;
export type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;
export type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
declare function _default$49<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<output<T>> | (() => util.NoUndefined<output<T>>)): schemas.$ZodDefault<T>;
export type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, "innerType">;
declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;
export type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;
export type $ZodCatchParams = TypeParams<schemas.$ZodCatch, "innerType" | "catchValue">;
declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: output<T> | ((ctx: schemas.$ZodCatchCtx) => output<T>)): schemas.$ZodCatch<T>;
export type $ZodPipeParams = TypeParams<schemas.$ZodPipe, "in" | "out">;
declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, output<A>> = schemas.$ZodType<unknown, output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, output<A>>): schemas.$ZodPipe<A, B>;
export type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, "innerType">;
declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;
export type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, "parts">;
declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;
export type $ZodLazyParams = TypeParams<schemas.$ZodLazy, "getter">;
declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;
export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;
export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
export type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue$1<T> : never;
type RawIssue$1<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
	/** The schema or check that originated this issue. */
	readonly inst?: schemas.$ZodType | $ZodCheck;
	/** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
	readonly continue?: boolean | undefined;
} & Record<string, unknown>> : never;
export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
	addIssue(arg: string | $ZodSuperRefineIssue): void;
}
declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): $ZodCheck<T>;
declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): $ZodCheck<O>;
declare function describe<T>(description: string): $ZodCheck<T>;
declare function meta<T>(metadata: GlobalMeta): $ZodCheck<T>;
export interface $ZodStringBoolParams extends TypeParams {
	truthy?: string[];
	falsy?: string[];
	/**
	 * Options: `"sensitive"`, `"insensitive"`
	 *
	 * @default `"insensitive"`
	 */
	case?: "sensitive" | "insensitive" | undefined;
}
declare function _stringbool(Classes: {
	Codec?: typeof schemas.$ZodCodec;
	Boolean?: typeof schemas.$ZodBoolean;
	String?: typeof schemas.$ZodString;
}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;
declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;
declare function toJSONSchema<T extends schemas.$ZodType>(schema: T, params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T>;
declare function toJSONSchema(registry: $ZodRegistry<{
	id?: string | undefined;
}>, params?: RegistryToJSONSchemaParams): {
	schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
};
/**
 * Parameters for the emit method of JSONSchemaGenerator.
 * @deprecated Use toJSONSchema function instead
 */
export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
/**
 * Parameters for JSONSchemaGenerator constructor.
 * @deprecated Use toJSONSchema function instead
 */
export type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
declare class JSONSchemaGenerator {
	private ctx;
	/** @deprecated Access via ctx instead */
	get metadataRegistry(): $ZodRegistry<Record<string, any>>;
	/** @deprecated Access via ctx instead */
	get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
	/** @deprecated Access via ctx instead */
	get unrepresentable(): "any" | "throw";
	/** @deprecated Access via ctx instead */
	get override(): (ctx: {
		zodSchema: schemas.$ZodType;
		jsonSchema: JSONSchema$1.BaseSchema;
		path: (string | number)[];
	}) => void;
	/** @deprecated Access via ctx instead */
	get io(): "input" | "output";
	/** @deprecated Access via ctx instead */
	get counter(): number;
	set counter(value: number);
	/** @deprecated Access via ctx instead */
	get seen(): Map<schemas.$ZodType, Seen>;
	constructor(params?: JSONSchemaGeneratorConstructorParams);
	/**
	 * Process a schema to prepare it for JSON Schema generation.
	 * This must be called before emit().
	 */
	process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema$1.BaseSchema;
	/**
	 * Emit the final JSON Schema after processing.
	 * Must call process() first.
	 */
	emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema$1.BaseSchema;
}
/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
export type ZodIssue = core.$ZodIssue;
/** An Error-like class used to store Zod validation issues.  */
export interface ZodError<T = unknown> extends $ZodError<T> {
	/** @deprecated Use the `z.treeifyError(err)` function instead. */
	format(): core.$ZodFormattedError<T>;
	format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
	/** @deprecated Use the `z.treeifyError(err)` function instead. */
	flatten(): core.$ZodFlattenedError<T>;
	flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
	/** @deprecated Push directly to `.issues` instead. */
	addIssue(issue: core.$ZodIssue): void;
	/** @deprecated Push directly to `.issues` instead. */
	addIssues(issues: core.$ZodIssue[]): void;
	/** @deprecated Check `err.issues.length === 0` instead. */
	isEmpty: boolean;
}
declare const ZodError: core.$constructor<ZodError>;
declare const ZodRealError: core.$constructor<ZodError>;
/** @deprecated Use `z.core.$ZodRawIssue` instead. */
export type IssueData = core.$ZodRawIssue;
export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
export type ZodSafeParseSuccess<T> = {
	success: true;
	data: T;
	error?: never;
};
export type ZodSafeParseError<T> = {
	success: false;
	data?: never;
	error: ZodError<T>;
};
declare const parse$1: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
	callee?: core.util.AnyFunc;
	Err?: core.$ZodErrorClass;
}) => core.output<T>;
declare const parseAsync$1: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {
	callee?: core.util.AnyFunc;
	Err?: core.$ZodErrorClass;
}) => Promise<core.output<T>>;
declare const safeParse$1: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
declare const safeParseAsync$1: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
declare const encode$1: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.input<T>;
declare const decode$1: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.output<T>;
declare const encodeAsync$1: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.input<T>>;
declare const decodeAsync$1: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.output<T>>;
declare const safeEncode$1: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.input<T>>;
declare const safeDecode$1: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;
declare const safeEncodeAsync$1: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.input<T>>>;
declare const safeDecodeAsync$1: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;
type ZodStandardSchemaWithJSON$1<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
export interface ZodType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$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"];
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	/** Converts this schema to a JSON Schema representation. */
	toJSONSchema(params?: core.ToJSONSchemaParams): core.ZodStandardJSONSchemaPayload<this>;
	check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
	with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
	clone(def?: Internals["def"], params?: {
		parent: boolean;
	}): this;
	register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [
		core.$replace<R["_meta"], this>?
	] : [
		core.$replace<R["_meta"], this>
	] : [
		"Incompatible schema"
	]): this;
	brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : core.$ZodBranded<this, T, Dir>;
	parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
	safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.output<this>>;
	parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
	safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.output<this>>>;
	spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<this>>>;
	encode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): core.input<this>;
	decode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
	encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.input<this>>;
	decodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
	safeEncode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.input<this>>;
	safeDecode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): ZodSafeParseResult<core.output<this>>;
	safeEncodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.input<this>>>;
	safeDecodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<ZodSafeParseResult<core.output<this>>>;
	refine<Ch extends (arg: core.output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | core.$ZodCustomParams): Ch extends (arg: any) => arg is infer R ? this & ZodType<R, core.input<this>> : this;
	superRefine(refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>): this;
	overwrite(fn: (x: core.output<this>) => core.output<this>): this;
	optional(): ZodOptional<this>;
	exactOptional(): ZodExactOptional<this>;
	nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
	nullable(): ZodNullable<this>;
	nullish(): ZodOptional<ZodNullable<this>>;
	default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;
	default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
	prefault(def: () => core.input<this>): ZodPrefault<this>;
	prefault(def: core.input<this>): ZodPrefault<this>;
	array(): ZodArray<this>;
	or<T extends core.SomeType>(option: T): ZodUnion<[
		this,
		T
	]>;
	and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T>;
	transform<NewOut>(transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
	catch(def: core.output<this>): ZodCatch<this>;
	catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodCatch<this>;
	pipe<T extends core.$ZodType<any, core.output<this>>>(target: T | core.$ZodType<any, core.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(): core.$replace<core.GlobalMeta, this> | undefined;
	/** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
	meta(data: core.$replace<core.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;
	apply<T>(fn: (schema: this) => T): T;
}
export interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodType<any, any, Internals> {
}
declare const ZodType: core.$constructor<ZodType>;
export interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>> extends _ZodType<T> {
	format: string | null;
	minLength: number | null;
	maxLength: number | null;
	regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;
	includes(value: string, params?: string | core.$ZodCheckIncludesParams): this;
	startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this;
	endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this;
	min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
	max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
	length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
	nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
	lowercase(params?: string | core.$ZodCheckLowerCaseParams): this;
	uppercase(params?: string | core.$ZodCheckUpperCaseParams): this;
	trim(): this;
	normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
	toLowerCase(): this;
	toUpperCase(): this;
	slugify(): this;
}
declare const _ZodString: core.$constructor<_ZodString>;
export interface ZodString extends _ZodString<core.$ZodStringInternals<string>> {
	/** @deprecated Use `z.email()` instead. */
	email(params?: string | core.$ZodCheckEmailParams): this;
	/** @deprecated Use `z.url()` instead. */
	url(params?: string | core.$ZodCheckURLParams): this;
	/** @deprecated Use `z.jwt()` instead. */
	jwt(params?: string | core.$ZodCheckJWTParams): this;
	/** @deprecated Use `z.emoji()` instead. */
	emoji(params?: string | core.$ZodCheckEmojiParams): this;
	/** @deprecated Use `z.guid()` instead. */
	guid(params?: string | core.$ZodCheckGUIDParams): this;
	/** @deprecated Use `z.uuid()` instead. */
	uuid(params?: string | core.$ZodCheckUUIDParams): this;
	/** @deprecated Use `z.uuid()` instead. */
	uuidv4(params?: string | core.$ZodCheckUUIDParams): this;
	/** @deprecated Use `z.uuid()` instead. */
	uuidv6(params?: string | core.$ZodCheckUUIDParams): this;
	/** @deprecated Use `z.uuid()` instead. */
	uuidv7(params?: string | core.$ZodCheckUUIDParams): this;
	/** @deprecated Use `z.nanoid()` instead. */
	nanoid(params?: string | core.$ZodCheckNanoIDParams): this;
	/** @deprecated Use `z.guid()` instead. */
	guid(params?: string | core.$ZodCheckGUIDParams): this;
	/** @deprecated Use `z.cuid()` instead. */
	cuid(params?: string | core.$ZodCheckCUIDParams): this;
	/** @deprecated Use `z.cuid2()` instead. */
	cuid2(params?: string | core.$ZodCheckCUID2Params): this;
	/** @deprecated Use `z.ulid()` instead. */
	ulid(params?: string | core.$ZodCheckULIDParams): this;
	/** @deprecated Use `z.base64()` instead. */
	base64(params?: string | core.$ZodCheckBase64Params): this;
	/** @deprecated Use `z.base64url()` instead. */
	base64url(params?: string | core.$ZodCheckBase64URLParams): this;
	/** @deprecated Use `z.xid()` instead. */
	xid(params?: string | core.$ZodCheckXIDParams): this;
	/** @deprecated Use `z.ksuid()` instead. */
	ksuid(params?: string | core.$ZodCheckKSUIDParams): this;
	/** @deprecated Use `z.ipv4()` instead. */
	ipv4(params?: string | core.$ZodCheckIPv4Params): this;
	/** @deprecated Use `z.ipv6()` instead. */
	ipv6(params?: string | core.$ZodCheckIPv6Params): this;
	/** @deprecated Use `z.cidrv4()` instead. */
	cidrv4(params?: string | core.$ZodCheckCIDRv4Params): this;
	/** @deprecated Use `z.cidrv6()` instead. */
	cidrv6(params?: string | core.$ZodCheckCIDRv6Params): this;
	/** @deprecated Use `z.e164()` instead. */
	e164(params?: string | core.$ZodCheckE164Params): this;
	/** @deprecated Use `z.iso.datetime()` instead. */
	datetime(params?: string | core.$ZodCheckISODateTimeParams): this;
	/** @deprecated Use `z.iso.date()` instead. */
	date(params?: string | core.$ZodCheckISODateParams): this;
	/** @deprecated Use `z.iso.time()` instead. */
	time(params?: string | core.$ZodCheckISOTimeParams): this;
	/** @deprecated Use `z.iso.duration()` instead. */
	duration(params?: string | core.$ZodCheckISODurationParams): this;
}
declare const ZodString: core.$constructor<ZodString>;
declare function string$1(params?: string | core.$ZodStringParams): ZodString;
declare function string$1<T extends string>(params?: string | core.$ZodStringParams): core.$ZodType<T, T>;
export interface ZodStringFormat<Format extends string = string> extends _ZodString<core.$ZodStringFormatInternals<Format>> {
}
declare const ZodStringFormat: core.$constructor<ZodStringFormat>;
export interface ZodEmail extends ZodStringFormat<"email"> {
	_zod: core.$ZodEmailInternals;
}
declare const ZodEmail: core.$constructor<ZodEmail>;
declare function email$1(params?: string | core.$ZodEmailParams): ZodEmail;
export interface ZodGUID extends ZodStringFormat<"guid"> {
	_zod: core.$ZodGUIDInternals;
}
declare const ZodGUID: core.$constructor<ZodGUID>;
declare function guid$1(params?: string | core.$ZodGUIDParams): ZodGUID;
export interface ZodUUID extends ZodStringFormat<"uuid"> {
	_zod: core.$ZodUUIDInternals;
}
declare const ZodUUID: core.$constructor<ZodUUID>;
declare function uuid$1(params?: string | core.$ZodUUIDParams): ZodUUID;
declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodUUID;
declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodUUID;
declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodUUID;
export interface ZodURL extends ZodStringFormat<"url"> {
	_zod: core.$ZodURLInternals;
}
declare const ZodURL: core.$constructor<ZodURL>;
declare function url(params?: string | core.$ZodURLParams): ZodURL;
declare function httpUrl(params?: string | Omit<core.$ZodURLParams, "protocol" | "hostname">): ZodURL;
export interface ZodEmoji extends ZodStringFormat<"emoji"> {
	_zod: core.$ZodEmojiInternals;
}
declare const ZodEmoji: core.$constructor<ZodEmoji>;
declare function emoji$1(params?: string | core.$ZodEmojiParams): ZodEmoji;
export interface ZodNanoID extends ZodStringFormat<"nanoid"> {
	_zod: core.$ZodNanoIDInternals;
}
declare const ZodNanoID: core.$constructor<ZodNanoID>;
declare function nanoid$1(params?: string | core.$ZodNanoIDParams): ZodNanoID;
export interface ZodCUID extends ZodStringFormat<"cuid"> {
	_zod: core.$ZodCUIDInternals;
}
declare const ZodCUID: core.$constructor<ZodCUID>;
declare function cuid$1(params?: string | core.$ZodCUIDParams): ZodCUID;
export interface ZodCUID2 extends ZodStringFormat<"cuid2"> {
	_zod: core.$ZodCUID2Internals;
}
declare const ZodCUID2: core.$constructor<ZodCUID2>;
declare function cuid2$1(params?: string | core.$ZodCUID2Params): ZodCUID2;
export interface ZodULID extends ZodStringFormat<"ulid"> {
	_zod: core.$ZodULIDInternals;
}
declare const ZodULID: core.$constructor<ZodULID>;
declare function ulid$1(params?: string | core.$ZodULIDParams): ZodULID;
export interface ZodXID extends ZodStringFormat<"xid"> {
	_zod: core.$ZodXIDInternals;
}
declare const ZodXID: core.$constructor<ZodXID>;
declare function xid$1(params?: string | core.$ZodXIDParams): ZodXID;
export interface ZodKSUID extends ZodStringFormat<"ksuid"> {
	_zod: core.$ZodKSUIDInternals;
}
declare const ZodKSUID: core.$constructor<ZodKSUID>;
declare function ksuid$1(params?: string | core.$ZodKSUIDParams): ZodKSUID;
export interface ZodIPv4 extends ZodStringFormat<"ipv4"> {
	_zod: core.$ZodIPv4Internals;
}
declare const ZodIPv4: core.$constructor<ZodIPv4>;
declare function ipv4$1(params?: string | core.$ZodIPv4Params): ZodIPv4;
export interface ZodMAC extends ZodStringFormat<"mac"> {
	_zod: core.$ZodMACInternals;
}
declare const ZodMAC: core.$constructor<ZodMAC>;
declare function mac$1(params?: string | core.$ZodMACParams): ZodMAC;
export interface ZodIPv6 extends ZodStringFormat<"ipv6"> {
	_zod: core.$ZodIPv6Internals;
}
declare const ZodIPv6: core.$constructor<ZodIPv6>;
declare function ipv6$1(params?: string | core.$ZodIPv6Params): ZodIPv6;
export interface ZodCIDRv4 extends ZodStringFormat<"cidrv4"> {
	_zod: core.$ZodCIDRv4Internals;
}
declare const ZodCIDRv4: core.$constructor<ZodCIDRv4>;
declare function cidrv4$1(params?: string | core.$ZodCIDRv4Params): ZodCIDRv4;
export interface ZodCIDRv6 extends ZodStringFormat<"cidrv6"> {
	_zod: core.$ZodCIDRv6Internals;
}
declare const ZodCIDRv6: core.$constructor<ZodCIDRv6>;
declare function cidrv6$1(params?: string | core.$ZodCIDRv6Params): ZodCIDRv6;
export interface ZodBase64 extends ZodStringFormat<"base64"> {
	_zod: core.$ZodBase64Internals;
}
declare const ZodBase64: core.$constructor<ZodBase64>;
declare function base64$1(params?: string | core.$ZodBase64Params): ZodBase64;
export interface ZodBase64URL extends ZodStringFormat<"base64url"> {
	_zod: core.$ZodBase64URLInternals;
}
declare const ZodBase64URL: core.$constructor<ZodBase64URL>;
declare function base64url$1(params?: string | core.$ZodBase64URLParams): ZodBase64URL;
export interface ZodE164 extends ZodStringFormat<"e164"> {
	_zod: core.$ZodE164Internals;
}
declare const ZodE164: core.$constructor<ZodE164>;
declare function e164$1(params?: string | core.$ZodE164Params): ZodE164;
export interface ZodJWT extends ZodStringFormat<"jwt"> {
	_zod: core.$ZodJWTInternals;
}
declare const ZodJWT: core.$constructor<ZodJWT>;
declare function jwt(params?: string | core.$ZodJWTParams): ZodJWT;
export interface ZodCustomStringFormat<Format extends string = string> extends ZodStringFormat<Format>, core.$ZodCustomStringFormat<Format> {
	_zod: core.$ZodCustomStringFormatInternals<Format>;
	"~standard": ZodStandardSchemaWithJSON$1<this>;
}
declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;
declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
declare function hostname$1(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname">;
declare function hex$1(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hex">;
declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(alg: Alg, params?: {
	enc?: Enc;
} & core.$ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;
export interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals> extends _ZodType<Internals> {
	gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
	/** Identical to .min() */
	gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
	min(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
	lt(value: number, params?: string | core.$ZodCheckLessThanParams): this;
	/** Identical to .max() */
	lte(value: number, params?: string | core.$ZodCheckLessThanParams): this;
	max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
	/** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
	int(params?: string | core.$ZodCheckNumberFormatParams): this;
	/** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
	safe(params?: string | core.$ZodCheckNumberFormatParams): this;
	positive(params?: string | core.$ZodCheckGreaterThanParams): this;
	nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
	negative(params?: string | core.$ZodCheckLessThanParams): this;
	nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
	multipleOf(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
	/** @deprecated Use `.multipleOf()` instead. */
	step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
	/** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
	finite(params?: unknown): this;
	minValue: number | null;
	maxValue: number | null;
	/** @deprecated Check the `format` property instead.  */
	isInt: boolean;
	/** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
	isFinite: boolean;
	format: string | null;
}
export interface ZodNumber extends _ZodNumber<core.$ZodNumberInternals<number>> {
}
declare const ZodNumber: core.$constructor<ZodNumber>;
declare function number$1(params?: string | core.$ZodNumberParams): ZodNumber;
export interface ZodNumberFormat extends ZodNumber {
	_zod: core.$ZodNumberFormatInternals;
}
declare const ZodNumberFormat: core.$constructor<ZodNumberFormat>;
export interface ZodInt extends ZodNumberFormat {
}
declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodInt;
export interface ZodFloat32 extends ZodNumberFormat {
}
declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat32;
export interface ZodFloat64 extends ZodNumberFormat {
}
declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat64;
export interface ZodInt32 extends ZodNumberFormat {
}
declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodInt32;
export interface ZodUInt32 extends ZodNumberFormat {
}
declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32;
export interface _ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals> extends _ZodType<T> {
}
export interface ZodBoolean extends _ZodBoolean<core.$ZodBooleanInternals<boolean>> {
}
declare const ZodBoolean: core.$constructor<ZodBoolean>;
declare function boolean$1(params?: string | core.$ZodBooleanParams): ZodBoolean;
export interface _ZodBigInt<T extends core.$ZodBigIntInternals = core.$ZodBigIntInternals> extends _ZodType<T> {
	gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
	/** Alias of `.gte()` */
	min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
	gt(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
	/** Alias of `.lte()` */
	lte(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
	max(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
	lt(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
	positive(params?: string | core.$ZodCheckGreaterThanParams): this;
	negative(params?: string | core.$ZodCheckLessThanParams): this;
	nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
	nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
	multipleOf(value: bigint, params?: string | core.$ZodCheckMultipleOfParams): this;
	minValue: bigint | null;
	maxValue: bigint | null;
	format: string | null;
}
export interface ZodBigInt extends _ZodBigInt<core.$ZodBigIntInternals<bigint>> {
}
declare const ZodBigInt: core.$constructor<ZodBigInt>;
declare function bigint$1(params?: string | core.$ZodBigIntParams): ZodBigInt;
export interface ZodBigIntFormat extends ZodBigInt {
	_zod: core.$ZodBigIntFormatInternals;
}
declare const ZodBigIntFormat: core.$constructor<ZodBigIntFormat>;
declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;
export interface ZodSymbol extends _ZodType<core.$ZodSymbolInternals> {
}
declare const ZodSymbol: core.$constructor<ZodSymbol>;
declare function symbol(params?: string | core.$ZodSymbolParams): ZodSymbol;
export interface ZodUndefined extends _ZodType<core.$ZodUndefinedInternals> {
}
declare const ZodUndefined: core.$constructor<ZodUndefined>;
declare function _undefined$2(params?: string | core.$ZodUndefinedParams): ZodUndefined;
export interface ZodNull extends _ZodType<core.$ZodNullInternals> {
}
declare const ZodNull: core.$constructor<ZodNull>;
declare function _null$2(params?: string | core.$ZodNullParams): ZodNull;
export interface ZodAny extends _ZodType<core.$ZodAnyInternals> {
}
declare const ZodAny: core.$constructor<ZodAny>;
declare function any(): ZodAny;
export interface ZodUnknown extends _ZodType<core.$ZodUnknownInternals> {
}
declare const ZodUnknown: core.$constructor<ZodUnknown>;
declare function unknown(): ZodUnknown;
export interface ZodNever extends _ZodType<core.$ZodNeverInternals> {
}
declare const ZodNever: core.$constructor<ZodNever>;
declare function never(params?: string | core.$ZodNeverParams): ZodNever;
export interface ZodVoid extends _ZodType<core.$ZodVoidInternals> {
}
declare const ZodVoid: core.$constructor<ZodVoid>;
declare function _void$1(params?: string | core.$ZodVoidParams): ZodVoid;
export interface _ZodDate<T extends core.$ZodDateInternals = core.$ZodDateInternals> extends _ZodType<T> {
	min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this;
	max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this;
	/** @deprecated Not recommended. */
	minDate: Date | null;
	/** @deprecated Not recommended. */
	maxDate: Date | null;
}
export interface ZodDate extends _ZodDate<core.$ZodDateInternals<Date>> {
}
declare const ZodDate: core.$constructor<ZodDate>;
declare function date$1(params?: string | core.$ZodDateParams): ZodDate;
export interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodArrayInternals<T>>, core.$ZodArray<T> {
	element: T;
	min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
	nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
	max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
	length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
	unwrap(): T;
	"~standard": ZodStandardSchemaWithJSON$1<this>;
}
declare const ZodArray: core.$constructor<ZodArray>;
declare function array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
declare function keyof<T extends ZodObject>(schema: T): ZodEnum<util.KeysEnum<T["_zod"]["output"]>>;
export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = {
	[K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
};
export interface ZodObject<
/** @ts-ignore Cast variance */
out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	shape: Shape;
	keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
	/** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
	catchall<T extends core.SomeType>(schema: T): ZodObject<Shape, core.$catchall<T>>;
	/** @deprecated Use `z.looseObject()` or `.loose()` instead. */
	passthrough(): ZodObject<Shape, core.$loose>;
	/** Consider `z.looseObject(A.shape)` instead */
	loose(): ZodObject<Shape, core.$loose>;
	/** Consider `z.strictObject(A.shape)` instead */
	strict(): ZodObject<Shape, core.$strict>;
	/** This is the default behavior. This method call is likely unnecessary. */
	strip(): ZodObject<Shape, core.$strip>;
	extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;
	safeExtend<U extends core.$ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): ZodObject<util.Extend<Shape, U>, Config>;
	/**
	 * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
	 */
	merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
	pick<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
	omit<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
	partial(): ZodObject<{
		[k in keyof Shape]: ZodOptional<Shape[k]>;
	}, Config>;
	partial<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): 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 util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{
		[k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];
	}, Config>;
}
declare const ZodObject: core.$constructor<ZodObject>;
declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T>, core.$strip>;
declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$strict>;
declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$loose>;
export interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$ZodType[]> extends _ZodType<core.$ZodUnionInternals<T>>, core.$ZodUnion<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	options: T;
}
declare const ZodUnion: core.$constructor<ZodUnion>;
declare function union<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T>;
export interface ZodXor<T extends readonly core.SomeType[] = readonly core.$ZodType[]> extends _ZodType<core.$ZodXorInternals<T>>, core.$ZodXor<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	options: T;
}
declare const ZodXor: core.$constructor<ZodXor>;
declare function xor<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodXorParams): ZodXor<T>;
export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[], Disc extends string = string> extends ZodUnion<Options>, core.$ZodDiscriminatedUnion<Options, Disc> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	_zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
	def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
}
declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
declare function discriminatedUnion<Types extends readonly [
	core.$ZodTypeDiscriminable,
	...core.$ZodTypeDiscriminable[]
], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
export interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodIntersectionInternals<A, B>>, core.$ZodIntersection<A, B> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
}
declare const ZodIntersection: core.$constructor<ZodIntersection>;
declare function intersection<T extends core.SomeType, U extends core.SomeType>(left: T, right: U): ZodIntersection<T, U>;
export interface ZodTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends core.SomeType | null = core.$ZodType | null> extends _ZodType<core.$ZodTupleInternals<T, Rest>>, core.$ZodTuple<T, Rest> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	rest<Rest extends core.SomeType = core.$ZodType>(rest: Rest): ZodTuple<T, Rest>;
}
declare const ZodTuple: core.$constructor<ZodTuple>;
declare function tuple<T extends readonly [
	core.SomeType,
	...core.SomeType[]
]>(items: T, params?: string | core.$ZodTupleParams): ZodTuple<T, null>;
declare function tuple<T extends readonly [
	core.SomeType,
	...core.SomeType[]
], Rest extends core.SomeType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodTuple<T, Rest>;
declare function tuple(items: [
], params?: string | core.$ZodTupleParams): ZodTuple<[
], null>;
export interface ZodRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodRecordInternals<Key, Value>>, core.$ZodRecord<Key, Value> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	keyType: Key;
	valueType: Value;
}
declare const ZodRecord: core.$constructor<ZodRecord>;
declare function record<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value>;
declare function partialRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key & core.$partial, Value>;
declare function looseRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value>;
export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodMapInternals<Key, Value>>, core.$ZodMap<Key, Value> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	keyType: Key;
	valueType: Value;
	min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
	nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
	max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
	size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
}
declare const ZodMap: core.$constructor<ZodMap>;
declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;
export interface ZodSet<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSetInternals<T>>, core.$ZodSet<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
	nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
	max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
	size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
}
declare const ZodSet: core.$constructor<ZodSet>;
declare function set<Value extends core.SomeType>(valueType: Value, params?: string | core.$ZodSetParams): ZodSet<Value>;
export interface ZodEnum<
/** @ts-ignore Cast variance */
out T extends util.EnumLike = util.EnumLike> extends _ZodType<core.$ZodEnumInternals<T>>, core.$ZodEnum<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	enum: T;
	options: Array<T[keyof T]>;
	extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Pick<T, U[number]>>>;
	exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Omit<T, U[number]>>>;
}
declare const ZodEnum: core.$constructor<ZodEnum>;
declare function _enum$1<const T extends readonly string[]>(values: T, params?: string | core.$ZodEnumParams): ZodEnum<util.ToEnum<T[number]>>;
declare function _enum$1<const T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T>;
declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T>;
export interface ZodLiteral<T extends util.Literal = util.Literal> extends _ZodType<core.$ZodLiteralInternals<T>>, core.$ZodLiteral<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	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: core.$constructor<ZodLiteral>;
declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;
declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T>;
export interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
	max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;
	mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;
}
declare const ZodFile: core.$constructor<ZodFile>;
declare function file(params?: string | core.$ZodFileParams): ZodFile;
export interface ZodTransform<O = unknown, I = unknown> extends _ZodType<core.$ZodTransformInternals<O, I>>, core.$ZodTransform<O, I> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
}
declare const ZodTransform: core.$constructor<ZodTransform>;
declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodTransform<Awaited<O>, I>;
export interface ZodOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodOptionalInternals<T>>, core.$ZodOptional<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodOptional: core.$constructor<ZodOptional>;
declare function optional<T extends core.SomeType>(innerType: T): ZodOptional<T>;
export interface ZodExactOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodExactOptionalInternals<T>>, core.$ZodExactOptional<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodExactOptional: core.$constructor<ZodExactOptional>;
declare function exactOptional<T extends core.SomeType>(innerType: T): ZodExactOptional<T>;
export interface ZodNullable<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodNullableInternals<T>>, core.$ZodNullable<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodNullable: core.$constructor<ZodNullable>;
declare function nullable<T extends core.SomeType>(innerType: T): ZodNullable<T>;
declare function nullish$1<T extends core.SomeType>(innerType: T): ZodOptional<ZodNullable<T>>;
export interface ZodDefault<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodDefaultInternals<T>>, core.$ZodDefault<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
	/** @deprecated Use `.unwrap()` instead. */
	removeDefault(): T;
}
declare const ZodDefault: core.$constructor<ZodDefault>;
declare function _default$50<T extends core.SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodDefault<T>;
export interface ZodPrefault<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPrefaultInternals<T>>, core.$ZodPrefault<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodPrefault: core.$constructor<ZodPrefault>;
declare function prefault<T extends core.SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodPrefault<T>;
export interface ZodNonOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodNonOptionalInternals<T>>, core.$ZodNonOptional<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodNonOptional: core.$constructor<ZodNonOptional>;
declare function nonoptional<T extends core.SomeType>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodNonOptional<T>;
export interface ZodSuccess<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSuccessInternals<T>>, core.$ZodSuccess<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodSuccess: core.$constructor<ZodSuccess>;
declare function success<T extends core.SomeType>(innerType: T): ZodSuccess<T>;
export interface ZodCatch<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodCatchInternals<T>>, core.$ZodCatch<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
	/** @deprecated Use `.unwrap()` instead. */
	removeCatch(): T;
}
declare const ZodCatch: core.$constructor<ZodCatch>;
declare function _catch$1<T extends core.SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodCatch<T>;
export interface ZodNaN extends _ZodType<core.$ZodNaNInternals>, core.$ZodNaN {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
}
declare const ZodNaN: core.$constructor<ZodNaN>;
declare function nan(params?: string | core.$ZodNaNParams): ZodNaN;
export interface ZodPipe<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPipeInternals<A, B>>, core.$ZodPipe<A, B> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	in: A;
	out: B;
}
declare const ZodPipe: core.$constructor<ZodPipe>;
declare function pipe<const A extends core.SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodPipe<A, B>;
export interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends ZodPipe<A, B>, core.$ZodCodec<A, B> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	_zod: core.$ZodCodecInternals<A, B>;
	def: core.$ZodCodecDef<A, B>;
}
declare const ZodCodec: core.$constructor<ZodCodec>;
declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {
	decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
	encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
}): ZodCodec<A, B>;
export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodReadonly: core.$constructor<ZodReadonly>;
declare function readonly<T extends core.SomeType>(innerType: T): ZodReadonly<T>;
export interface ZodTemplateLiteral<Template extends string = string> extends _ZodType<core.$ZodTemplateLiteralInternals<Template>>, core.$ZodTemplateLiteral<Template> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
}
declare const ZodTemplateLiteral: core.$constructor<ZodTemplateLiteral>;
declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;
export interface ZodLazy<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodLazyInternals<T>>, core.$ZodLazy<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodLazy: core.$constructor<ZodLazy>;
declare function lazy<T extends core.SomeType>(getter: () => T): ZodLazy<T>;
export interface ZodPromise<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPromiseInternals<T>>, core.$ZodPromise<T> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	unwrap(): T;
}
declare const ZodPromise: core.$constructor<ZodPromise>;
declare function promise<T extends core.SomeType>(innerType: T): ZodPromise<T>;
export interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctionIn, Returns extends core.$ZodFunctionOut = core.$ZodFunctionOut> extends _ZodType<core.$ZodFunctionInternals<Args, Returns>>, core.$ZodFunction<Args, Returns> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
	_def: core.$ZodFunctionDef<Args, Returns>;
	_input: core.$InferInnerFunctionType<Args, Returns>;
	_output: core.$InferOuterFunctionType<Args, Returns>;
	input<const Items extends util.TupleItems, const Rest extends core.$ZodFunctionOut = core.$ZodFunctionOut>(args: Items, rest?: Rest): ZodFunction<core.$ZodTuple<Items, Rest>, Returns>;
	input<NewArgs extends core.$ZodFunctionIn>(args: NewArgs): ZodFunction<NewArgs, Returns>;
	input(...args: any[]): ZodFunction<any, Returns>;
	output<NewReturns extends core.$ZodType>(output: NewReturns): ZodFunction<Args, NewReturns>;
}
declare const ZodFunction: core.$constructor<ZodFunction>;
declare function _function(): ZodFunction;
declare function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
	input: In;
}): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
	input: In;
	output: Out;
}): ZodFunction<ZodTuple<In, null>, Out>;
declare function _function<const In extends core.$ZodFunctionIn = core.$ZodFunctionIn>(params: {
	input: In;
}): ZodFunction<In, core.$ZodFunctionOut>;
declare function _function<const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
	output: Out;
}): ZodFunction<core.$ZodFunctionIn, Out>;
declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunctionIn, Out extends core.$ZodType = core.$ZodType>(params?: {
	input: In;
	output: Out;
}): ZodFunction<In, Out>;
export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodCustomInternals<O, I>>, core.$ZodCustom<O, I> {
	"~standard": ZodStandardSchemaWithJSON$1<this>;
}
declare const ZodCustom: core.$constructor<ZodCustom>;
declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
declare const describe$1: typeof core.describe;
declare const meta$1: typeof core.meta;
export type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean>;
export type _ZodJSONSchema = ZodUnion<[
	ZodString,
	ZodNumber,
	ZodBoolean,
	ZodNull,
	ZodArray<ZodJSONSchema>,
	ZodRecord<ZodString, ZodJSONSchema>
]>;
export type _ZodJSONSchemaInternals = _ZodJSONSchema["_zod"];
export interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
	output: util.JSONType;
	input: util.JSONType;
}
export interface ZodJSONSchema extends _ZodJSONSchema {
	_zod: ZodJSONSchemaInternals;
}
declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;
declare const ZodIssueCode: {
	readonly invalid_type: "invalid_type";
	readonly too_big: "too_big";
	readonly too_small: "too_small";
	readonly invalid_format: "invalid_format";
	readonly not_multiple_of: "not_multiple_of";
	readonly unrecognized_keys: "unrecognized_keys";
	readonly invalid_union: "invalid_union";
	readonly invalid_key: "invalid_key";
	readonly invalid_element: "invalid_element";
	readonly invalid_value: "invalid_value";
	readonly custom: "custom";
};
/** @deprecated Use `z.$ZodFlattenedError` */
export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
/** @deprecated Use `z.$ZodFormattedError` */
export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<core.output<T>, U>;
/** Use `z.$brand` instead */
export type BRAND<T extends string | number | symbol = string | number | symbol> = {
	[core.$brand]: {
		[k in T]: true;
	};
};
declare function setErrorMap(map: core.$ZodErrorMap): void;
declare function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined;
/** Included for Zod 3 compatibility */
export type ZodRawShape = core.$ZodShape;
declare enum ZodFirstPartyTypeKind {
}
export type JSONSchemaVersion = "draft-2020-12" | "draft-7" | "draft-4" | "openapi-3.0";
export interface FromJSONSchemaParams {
	defaultTarget?: JSONSchemaVersion;
	registry?: $ZodRegistry<any>;
}
declare function fromJSONSchema(schema: JSONSchema$1.JSONSchema | boolean, params?: FromJSONSchemaParams): ZodType;
export interface ZodISODateTime extends schemas$1.ZodStringFormat {
	_zod: core.$ZodISODateTimeInternals;
}
declare const ZodISODateTime: core.$constructor<ZodISODateTime>;
declare function datetime$1(params?: string | core.$ZodISODateTimeParams): ZodISODateTime;
export interface ZodISODate extends schemas$1.ZodStringFormat {
	_zod: core.$ZodISODateInternals;
}
declare const ZodISODate: core.$constructor<ZodISODate>;
declare function date$2(params?: string | core.$ZodISODateParams): ZodISODate;
export interface ZodISOTime extends schemas$1.ZodStringFormat {
	_zod: core.$ZodISOTimeInternals;
}
declare const ZodISOTime: core.$constructor<ZodISOTime>;
declare function time$1(params?: string | core.$ZodISOTimeParams): ZodISOTime;
export interface ZodISODuration extends schemas$1.ZodStringFormat {
	_zod: core.$ZodISODurationInternals;
}
declare const ZodISODuration: core.$constructor<ZodISODuration>;
declare function duration$1(params?: string | core.$ZodISODurationParams): ZodISODuration;
export interface ZodCoercedString<T = unknown> extends schemas$1._ZodString<core.$ZodStringInternals<T>> {
}
declare function string$2<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T>;
export interface ZodCoercedNumber<T = unknown> extends schemas$1._ZodNumber<core.$ZodNumberInternals<T>> {
}
declare function number$2<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;
export interface ZodCoercedBoolean<T = unknown> extends schemas$1._ZodBoolean<core.$ZodBooleanInternals<T>> {
}
declare function boolean$2<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;
export interface ZodCoercedBigInt<T = unknown> extends schemas$1._ZodBigInt<core.$ZodBigIntInternals<T>> {
}
declare function bigint$2<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;
export interface ZodCoercedDate<T = unknown> extends schemas$1._ZodDate<core.$ZodDateInternals<T>> {
}
declare function date$3<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;
declare const routeSchema: z.ZodDiscriminatedUnion<[
	z.ZodObject<{
		name: z.ZodLiteral<"start-page">;
		prefill: z.ZodOptional<z.ZodString>;
	}, z.core.$strip>,
	z.ZodObject<{
		name: z.ZodLiteral<"consent-page">;
	}, z.core.$strip>,
	z.ZodObject<{
		name: z.ZodLiteral<"chat-page">;
		query: z.ZodString;
	}, z.core.$strip>
], "name">;
declare const conversationStateSchema: z.ZodEnum<{
	idle: "idle";
	searching: "searching";
	answering: "answering";
}>;
export type Route = z.infer<typeof routeSchema>;
export type ConversationState = z.infer<typeof conversationStateSchema>;
declare const errorTranslationSchema: z.ZodObject<{
	blocked: z.ZodString;
	maintenance: z.ZodString;
	"rate-limit": z.ZodString;
	"server-error": z.ZodString;
	"too-short": z.ZodString;
	"too-long": z.ZodString;
	"quota-reached": z.ZodString;
	aborted: z.ZodString;
	"sse-error": z.ZodString;
	"client-error": z.ZodString;
	"unexpected-call": z.ZodString;
	"incomplete-error": z.ZodString;
	"feedback-failed": z.ZodString;
	"speech-not-supported": z.ZodString;
	"speech-transcription-failed": z.ZodString;
	"speech-no-text-detected": z.ZodString;
	"speech-microphone-access-denied": z.ZodString;
	"pii-detected": z.ZodString;
}, z.core.$strip>;
declare const chatSelectorTranslationSchema: z.ZodObject<{
	name: z.ZodString;
	namePlural: z.ZodOptional<z.ZodString>;
	intro: z.ZodOptional<z.ZodString>;
	placeholder: z.ZodString;
	values: z.ZodRecord<z.ZodString, z.ZodString>;
}, z.core.$strip>;
declare const translationSchema: z.ZodObject<{
	introductionTitle: z.ZodString;
	introductionDisclaimer: z.ZodOptional<z.ZodString>;
	termsInvitationToConsent: z.ZodOptional<z.ZodString>;
	chatInputPlaceholder: z.ZodString;
	chatInputPlaceholderListening: z.ZodOptional<z.ZodString>;
	chatInputSubmit: z.ZodString;
	chatInputAbort: z.ZodString;
	chatInputStartListening: z.ZodString;
	chatInputStopListening: z.ZodString;
	referenceLink: z.ZodString;
	referencesDisplay: z.ZodString;
	referencesHide: z.ZodString;
	referencesTitle: z.ZodString;
	referencesFurtherTitle: z.ZodString;
	newChat: z.ZodString;
	maintenanceModeError: z.ZodString;
	messageBotLoading: z.ZodString;
	messageBotError: z.ZodString;
	messageBotDefaultError: z.ZodString;
	noResultsFound: z.ZodString;
	chatFooterText: z.ZodOptional<z.ZodString>;
	scrollToBottom: z.ZodString;
	openButtonTitle: z.ZodOptional<z.ZodString>;
	openButtonDescription: z.ZodOptional<z.ZodString>;
	openMenu: z.ZodString;
	openInfo: z.ZodString;
	aboutThisChat: z.ZodOptional<z.ZodString>;
	closeMenu: z.ZodString;
	closeChat: z.ZodString;
	close: z.ZodString;
	send: z.ZodString;
	thankYouForFeedback: z.ZodString;
	giveFeedback: z.ZodString;
	sendFeedback: z.ZodString;
	feedbackFormTitle: z.ZodString;
	feedbackFormMessage: z.ZodString;
	feedbackFormMessagePlaceholder: z.ZodString;
	feedbackFormEmail: z.ZodString;
	feedbackFormEmailPlaceholder: z.ZodString;
	askQuestionAgain: z.ZodString;
	answerGood: z.ZodString;
	answerBad: z.ZodString;
	classificationSubmit: z.ZodString;
	classificationThankYou: z.ZodString;
	classificationTitle: z.ZodString;
	selectLanguage: z.ZodString;
	languageChanged: z.ZodString;
	selectColorTheme: z.ZodString;
	lightMode: z.ZodString;
	darkMode: z.ZodString;
	ariaMainNavigation: z.ZodString;
	ariaMainNavigationRegion: z.ZodString;
	ariaGotoMainNavigation: z.ZodString;
	ariaAskQuestion: z.ZodString;
	ariaAskQuestionRegion: z.ZodString;
	ariaNotifications: z.ZodString;
	ariaPredefinedQuestions: z.ZodString;
	ariaPredefinedQuestionsRegion: z.ZodString;
	ariaChatHistory: z.ZodString;
	ariaOpenChat: z.ZodString;
	ariaQuestionFromYou: z.ZodString;
	ariaAnswerFromBot: z.ZodString;
	ariaLastAnswerNavigation: z.ZodString;
	ariaQuestionSent: z.ZodString;
	ariaAnswerReady: z.ZodString;
	ariaAnswerFinished: z.ZodString;
	ariaAskQuestionAgain: z.ZodString;
	ariaAnswerGood: z.ZodString;
	ariaAnswerBad: z.ZodString;
	ariaReferenceSource: z.ZodString;
	ariaGiveFeedback: z.ZodString;
	ariaLanguageChanged: z.ZodString;
	ariaLightSelected: z.ZodString;
	ariaDarkSelected: z.ZodString;
	ariaSettings: z.ZodString;
	ariaSettingsRegion: z.ZodString;
	ariaReferencesRegion: z.ZodString;
	ariaOpensInNewTab: z.ZodString;
	ariaFlyoutRegion: z.ZodString;
	ariaSelected: z.ZodString;
	ariaUnselected: z.ZodString;
	ariaAllSelected: z.ZodString;
	ariaAllUnselected: z.ZodString;
	ariaAllReseted: z.ZodString;
	popups: z.ZodOptional<z.ZodArray<z.ZodObject<{
		hash: z.ZodString;
		title: z.ZodString;
		content: z.ZodString;
		actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
			action: z.ZodString;
			label: z.ZodString;
			type: z.ZodOptional<z.ZodEnum<{
				primary: "primary";
				secondary: "secondary";
			}>>;
		}, z.core.$strip>>>;
	}, z.core.$strip>>>;
	termsAcceptButton: z.ZodOptional<z.ZodString>;
	termsReadButton: z.ZodOptional<z.ZodString>;
	selectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
		name: z.ZodString;
		namePlural: z.ZodOptional<z.ZodString>;
		intro: z.ZodOptional<z.ZodString>;
		placeholder: z.ZodString;
		values: z.ZodRecord<z.ZodString, z.ZodString>;
	}, z.core.$strip>>>;
	hideSettings: z.ZodString;
	showSettings: z.ZodString;
	chooseAtLeastOneOption: z.ZodString;
	selectAll: z.ZodString;
	selectNone: z.ZodString;
	resetToDefaults: z.ZodString;
	messageTooLong: z.ZodString;
}, z.core.$strip>;
declare const languagesSchema: z.ZodEnum<{
	en: "en";
	de: "de";
	fr: "fr";
	it: "it";
}>;
export type Language = z.infer<typeof languagesSchema>;
export type Translation = z.infer<typeof translationSchema>;
export type ErrorTranslation = z.infer<typeof errorTranslationSchema>;
export type Translations = Record<Language, Translation>;
export type SelectorTranslation = z.infer<typeof chatSelectorTranslationSchema>;
export type TranslationsPartial = Partial<Record<Language, Omit<Partial<Translation>, "selectors"> & {
	selectors?: Record<string, SelectorTranslation>;
}>>;
declare const SnippetReturn: unique symbol;
// Use an interface instead of a type, makes for better intellisense info because the type is named in more situations.
/**
 * The type of a `#snippet` block. You can use it to (for example) express that your component expects a snippet of a certain type:
 * ```ts
 * let { banner }: { banner: Snippet<[{ text: string }]> } = $props();
 * ```
 * You can only call a snippet through the `{@render ...}` tag.
 *
 * See the [snippet documentation](https://svelte.dev/docs/svelte/snippet) for more info.
 *
 * @template Parameters the parameters that the snippet expects (if any) as a tuple.
 */
export interface Snippet<Parameters extends unknown[] = [
]> {
	(this: void, 
	// this conditional allows tuples but not arrays. Arrays would indicate a
	// rest parameter type, which is not supported. If rest parameters are added
	// in the future, the condition can be removed.
	...args: number extends Parameters["length"] ? never : Parameters): {
		"{@render ...} must be called with a Snippet": "import type { Snippet } from 'svelte'";
	} & typeof SnippetReturn;
}
/**
 * An [attachment](https://svelte.dev/docs/svelte/@attach) is a function that runs when an element is mounted
 * to the DOM, and optionally returns a function that is called when the element is later removed.
 *
 * It can be attached to an element with an `{@attach ...}` tag, or by spreading an object containing
 * a property created with [`createAttachmentKey`](https://svelte.dev/docs/svelte/svelte-attachments#createAttachmentKey).
 */
export interface Attachment<T extends EventTarget = Element> {
	(element: T): void | (() => void);
}
// Note: We also allow `null` as a valid value because Svelte treats this the same as `undefined`
export type Booleanish = boolean | "true" | "false";
//
// Event Handler Types
// ----------------------------------------------------------------------
export type EventHandler<E extends Event = Event, T extends EventTarget = Element> = (event: E & {
	currentTarget: EventTarget & T;
}) => any;
export type ClipboardEventHandler<T extends EventTarget> = EventHandler<ClipboardEvent, T>;
export type CompositionEventHandler<T extends EventTarget> = EventHandler<CompositionEvent, T>;
export type DragEventHandler<T extends EventTarget> = EventHandler<DragEvent, T>;
export type FocusEventHandler<T extends EventTarget> = EventHandler<FocusEvent, T>;
export type FormEventHandler<T extends EventTarget> = EventHandler<Event, T>;
export type ChangeEventHandler<T extends EventTarget> = EventHandler<Event, T>;
export type KeyboardEventHandler<T extends EventTarget> = EventHandler<KeyboardEvent, T>;
export type MouseEventHandler<T extends EventTarget> = EventHandler<MouseEvent, T>;
export type TouchEventHandler<T extends EventTarget> = EventHandler<TouchEvent, T>;
export type PointerEventHandler<T extends EventTarget> = EventHandler<PointerEvent, T>;
export type GamepadEventHandler<T extends EventTarget> = EventHandler<GamepadEvent, T>;
export type UIEventHandler<T extends EventTarget> = EventHandler<UIEvent, T>;
export type WheelEventHandler<T extends EventTarget> = EventHandler<WheelEvent, T>;
export type AnimationEventHandler<T extends EventTarget> = EventHandler<AnimationEvent, T>;
export type TransitionEventHandler<T extends EventTarget> = EventHandler<TransitionEvent, T>;
export type MessageEventHandler<T extends EventTarget> = EventHandler<MessageEvent, T>;
export type ToggleEventHandler<T extends EventTarget> = EventHandler<ToggleEvent, T>;
export type ContentVisibilityAutoStateChangeEventHandler<T extends EventTarget> = EventHandler<ContentVisibilityAutoStateChangeEvent, T>;
export type FullAutoFill = AutoFill | "bday" | `${OptionalPrefixToken<AutoFillAddressKind>}${"cc-additional-name"}` | "nickname" | "language" | "organization-title" | "photo" | "sex" | "url";
//
// DOM Attributes
// ----------------------------------------------------------------------
export interface DOMAttributes<T extends EventTarget> {
	// Implicit children prop every element has
	// Add this here so that libraries doing `let { ...props }: HTMLButtonAttributes = $props()` don't need a separate interface
	children?: Snippet;
	// Clipboard Events
	"on:copy"?: ClipboardEventHandler<T> | undefined | null;
	oncopy?: ClipboardEventHandler<T> | undefined | null;
	oncopycapture?: ClipboardEventHandler<T> | undefined | null;
	"on:cut"?: ClipboardEventHandler<T> | undefined | null;
	oncut?: ClipboardEventHandler<T> | undefined | null;
	oncutcapture?: ClipboardEventHandler<T> | undefined | null;
	"on:paste"?: ClipboardEventHandler<T> | undefined | null;
	onpaste?: ClipboardEventHandler<T> | undefined | null;
	onpastecapture?: ClipboardEventHandler<T> | undefined | null;
	// Composition Events
	"on:compositionend"?: CompositionEventHandler<T> | undefined | null;
	oncompositionend?: CompositionEventHandler<T> | undefined | null;
	oncompositionendcapture?: CompositionEventHandler<T> | undefined | null;
	"on:compositionstart"?: CompositionEventHandler<T> | undefined | null;
	oncompositionstart?: CompositionEventHandler<T> | undefined | null;
	oncompositionstartcapture?: CompositionEventHandler<T> | undefined | null;
	"on:compositionupdate"?: CompositionEventHandler<T> | undefined | null;
	oncompositionupdate?: CompositionEventHandler<T> | undefined | null;
	oncompositionupdatecapture?: CompositionEventHandler<T> | undefined | null;
	// Focus Events
	"on:focus"?: FocusEventHandler<T> | undefined | null;
	onfocus?: FocusEventHandler<T> | undefined | null;
	onfocuscapture?: FocusEventHandler<T> | undefined | null;
	"on:focusin"?: FocusEventHandler<T> | undefined | null;
	onfocusin?: FocusEventHandler<T> | undefined | null;
	onfocusincapture?: FocusEventHandler<T> | undefined | null;
	"on:focusout"?: FocusEventHandler<T> | undefined | null;
	onfocusout?: FocusEventHandler<T> | undefined | null;
	onfocusoutcapture?: FocusEventHandler<T> | undefined | null;
	"on:blur"?: FocusEventHandler<T> | undefined | null;
	onblur?: FocusEventHandler<T> | undefined | null;
	onblurcapture?: FocusEventHandler<T> | undefined | null;
	// Form Events
	"on:change"?: FormEventHandler<T> | undefined | null;
	onchange?: FormEventHandler<T> | undefined | null;
	onchangecapture?: FormEventHandler<T> | undefined | null;
	"on:beforeinput"?: EventHandler<InputEvent, T> | undefined | null;
	onbeforeinput?: EventHandler<InputEvent, T> | undefined | null;
	onbeforeinputcapture?: EventHandler<InputEvent, T> | undefined | null;
	// oninput can be either an InputEvent or an Event, depending on the target element (input, textarea etc).
	"on:input"?: FormEventHandler<T> | undefined | null;
	oninput?: FormEventHandler<T> | undefined | null;
	oninputcapture?: FormEventHandler<T> | undefined | null;
	"on:reset"?: FormEventHandler<T> | undefined | null;
	onreset?: FormEventHandler<T> | undefined | null;
	onresetcapture?: FormEventHandler<T> | undefined | null;
	"on:submit"?: EventHandler<SubmitEvent, T> | undefined | null;
	onsubmit?: EventHandler<SubmitEvent, T> | undefined | null;
	onsubmitcapture?: EventHandler<SubmitEvent, T> | undefined | null;
	"on:invalid"?: EventHandler<Event, T> | undefined | null;
	oninvalid?: EventHandler<Event, T> | undefined | null;
	oninvalidcapture?: EventHandler<Event, T> | undefined | null;
	"on:formdata"?: EventHandler<FormDataEvent, T> | undefined | null;
	onformdata?: EventHandler<FormDataEvent, T> | undefined | null;
	onformdatacapture?: EventHandler<FormDataEvent, T> | undefined | null;
	// Image Events
	"on:load"?: EventHandler | undefined | null;
	onload?: EventHandler | undefined | null;
	onloadcapture?: EventHandler | undefined | null;
	"on:error"?: EventHandler | undefined | null; // also a Media Event
	onerror?: EventHandler | undefined | null; // also a Media Event
	onerrorcapture?: EventHandler | undefined | null; // also a Media Event
	// Popover Events
	"on:beforetoggle"?: ToggleEventHandler<T> | undefined | null;
	onbeforetoggle?: ToggleEventHandler<T> | undefined | null;
	onbeforetogglecapture?: ToggleEventHandler<T> | undefined | null;
	"on:toggle"?: ToggleEventHandler<T> | undefined | null;
	ontoggle?: ToggleEventHandler<T> | undefined | null;
	ontogglecapture?: ToggleEventHandler<T> | undefined | null;
	// Content visibility Events
	"on:contentvisibilityautostatechange"?: ContentVisibilityAutoStateChangeEventHandler<T> | undefined | null;
	oncontentvisibilityautostatechange?: ContentVisibilityAutoStateChangeEventHandler<T> | undefined | null;
	oncontentvisibilityautostatechangecapture?: ContentVisibilityAutoStateChangeEventHandler<T> | undefined | null;
	// Keyboard Events
	"on:keydown"?: KeyboardEventHandler<T> | undefined | null;
	onkeydown?: KeyboardEventHandler<T> | undefined | null;
	onkeydowncapture?: KeyboardEventHandler<T> | undefined | null;
	"on:keypress"?: KeyboardEventHandler<T> | undefined | null;
	onkeypress?: KeyboardEventHandler<T> | undefined | null;
	onkeypresscapture?: KeyboardEventHandler<T> | undefined | null;
	"on:keyup"?: KeyboardEventHandler<T> | undefined | null;
	onkeyup?: KeyboardEventHandler<T> | undefined | null;
	onkeyupcapture?: KeyboardEventHandler<T> | undefined | null;
	// Media Events
	"on:abort"?: EventHandler<Event, T> | undefined | null;
	onabort?: EventHandler<Event, T> | undefined | null;
	onabortcapture?: EventHandler<Event, T> | undefined | null;
	"on:canplay"?: EventHandler<Event, T> | undefined | null;
	oncanplay?: EventHandler<Event, T> | undefined | null;
	oncanplaycapture?: EventHandler<Event, T> | undefined | null;
	"on:canplaythrough"?: EventHandler<Event, T> | undefined | null;
	oncanplaythrough?: EventHandler<Event, T> | undefined | null;
	oncanplaythroughcapture?: EventHandler<Event, T> | undefined | null;
	"on:cuechange"?: EventHandler<Event, T> | undefined | null;
	oncuechange?: EventHandler<Event, T> | undefined | null;
	oncuechangecapture?: EventHandler<Event, T> | undefined | null;
	"on:durationchange"?: EventHandler<Event, T> | undefined | null;
	ondurationchange?: EventHandler<Event, T> | undefined | null;
	ondurationchangecapture?: EventHandler<Event, T> | undefined | null;
	"on:emptied"?: EventHandler<Event, T> | undefined | null;
	onemptied?: EventHandler<Event, T> | undefined | null;
	onemptiedcapture?: EventHandler<Event, T> | undefined | null;
	"on:encrypted"?: EventHandler<Event, T> | undefined | null;
	onencrypted?: EventHandler<Event, T> | undefined | null;
	onencryptedcapture?: EventHandler<Event, T> | undefined | null;
	"on:ended"?: EventHandler<Event, T> | undefined | null;
	onended?: EventHandler<Event, T> | undefined | null;
	onendedcapture?: EventHandler<Event, T> | undefined | null;
	"on:loadeddata"?: EventHandler<Event, T> | undefined | null;
	onloadeddata?: EventHandler<Event, T> | undefined | null;
	onloadeddatacapture?: EventHandler<Event, T> | undefined | null;
	"on:loadedmetadata"?: EventHandler<Event, T> | undefined | null;
	onloadedmetadata?: EventHandler<Event, T> | undefined | null;
	onloadedmetadatacapture?: EventHandler<Event, T> | undefined | null;
	"on:loadstart"?: EventHandler<Event, T> | undefined | null;
	onloadstart?: EventHandler<Event, T> | undefined | null;
	onloadstartcapture?: EventHandler<Event, T> | undefined | null;
	"on:pause"?: EventHandler<Event, T> | undefined | null;
	onpause?: EventHandler<Event, T> | undefined | null;
	onpausecapture?: EventHandler<Event, T> | undefined | null;
	"on:play"?: EventHandler<Event, T> | undefined | null;
	onplay?: EventHandler<Event, T> | undefined | null;
	onplaycapture?: EventHandler<Event, T> | undefined | null;
	"on:playing"?: EventHandler<Event, T> | undefined | null;
	onplaying?: EventHandler<Event, T> | undefined | null;
	onplayingcapture?: EventHandler<Event, T> | undefined | null;
	"on:progress"?: EventHandler<Event, T> | undefined | null;
	onprogress?: EventHandler<Event, T> | undefined | null;
	onprogresscapture?: EventHandler<Event, T> | undefined | null;
	"on:ratechange"?: EventHandler<Event, T> | undefined | null;
	onratechange?: EventHandler<Event, T> | undefined | null;
	onratechangecapture?: EventHandler<Event, T> | undefined | null;
	"on:seeked"?: EventHandler<Event, T> | undefined | null;
	onseeked?: EventHandler<Event, T> | undefined | null;
	onseekedcapture?: EventHandler<Event, T> | undefined | null;
	"on:seeking"?: EventHandler<Event, T> | undefined | null;
	onseeking?: EventHandler<Event, T> | undefined | null;
	onseekingcapture?: EventHandler<Event, T> | undefined | null;
	"on:stalled"?: EventHandler<Event, T> | undefined | null;
	onstalled?: EventHandler<Event, T> | undefined | null;
	onstalledcapture?: EventHandler<Event, T> | undefined | null;
	"on:suspend"?: EventHandler<Event, T> | undefined | null;
	onsuspend?: EventHandler<Event, T> | undefined | null;
	onsuspendcapture?: EventHandler<Event, T> | undefined | null;
	"on:timeupdate"?: EventHandler<Event, T> | undefined | null;
	ontimeupdate?: EventHandler<Event, T> | undefined | null;
	ontimeupdatecapture?: EventHandler<Event, T> | undefined | null;
	"on:volumechange"?: EventHandler<Event, T> | undefined | null;
	onvolumechange?: EventHandler<Event, T> | undefined | null;
	onvolumechangecapture?: EventHandler<Event, T> | undefined | null;
	"on:waiting"?: EventHandler<Event, T> | undefined | null;
	onwaiting?: EventHandler<Event, T> | undefined | null;
	onwaitingcapture?: EventHandler<Event, T> | undefined | null;
	// MouseEvents
	"on:auxclick"?: MouseEventHandler<T> | undefined | null;
	onauxclick?: MouseEventHandler<T> | undefined | null;
	onauxclickcapture?: MouseEventHandler<T> | undefined | null;
	"on:click"?: MouseEventHandler<T> | undefined | null;
	onclick?: MouseEventHandler<T> | undefined | null;
	onclickcapture?: MouseEventHandler<T> | undefined | null;
	"on:contextmenu"?: MouseEventHandler<T> | undefined | null;
	oncontextmenu?: MouseEventHandler<T> | undefined | null;
	oncontextmenucapture?: MouseEventHandler<T> | undefined | null;
	"on:dblclick"?: MouseEventHandler<T> | undefined | null;
	ondblclick?: MouseEventHandler<T> | undefined | null;
	ondblclickcapture?: MouseEventHandler<T> | undefined | null;
	"on:drag"?: DragEventHandler<T> | undefined | null;
	ondrag?: DragEventHandler<T> | undefined | null;
	ondragcapture?: DragEventHandler<T> | undefined | null;
	"on:dragend"?: DragEventHandler<T> | undefined | null;
	ondragend?: DragEventHandler<T> | undefined | null;
	ondragendcapture?: DragEventHandler<T> | undefined | null;
	"on:dragenter"?: DragEventHandler<T> | undefined | null;
	ondragenter?: DragEventHandler<T> | undefined | null;
	ondragentercapture?: DragEventHandler<T> | undefined | null;
	"on:dragexit"?: DragEventHandler<T> | undefined | null;
	ondragexit?: DragEventHandler<T> | undefined | null;
	ondragexitcapture?: DragEventHandler<T> | undefined | null;
	"on:dragleave"?: DragEventHandler<T> | undefined | null;
	ondragleave?: DragEventHandler<T> | undefined | null;
	ondragleavecapture?: DragEventHandler<T> | undefined | null;
	"on:dragover"?: DragEventHandler<T> | undefined | null;
	ondragover?: DragEventHandler<T> | undefined | null;
	ondragovercapture?: DragEventHandler<T> | undefined | null;
	"on:dragstart"?: DragEventHandler<T> | undefined | null;
	ondragstart?: DragEventHandler<T> | undefined | null;
	ondragstartcapture?: DragEventHandler<T> | undefined | null;
	"on:drop"?: DragEventHandler<T> | undefined | null;
	ondrop?: DragEventHandler<T> | undefined | null;
	ondropcapture?: DragEventHandler<T> | undefined | null;
	"on:mousedown"?: MouseEventHandler<T> | undefined | null;
	onmousedown?: MouseEventHandler<T> | undefined | null;
	onmousedowncapture?: MouseEventHandler<T> | undefined | null;
	"on:mouseenter"?: MouseEventHandler<T> | undefined | null;
	onmouseenter?: MouseEventHandler<T> | undefined | null;
	"on:mouseleave"?: MouseEventHandler<T> | undefined | null;
	onmouseleave?: MouseEventHandler<T> | undefined | null;
	"on:mousemove"?: MouseEventHandler<T> | undefined | null;
	onmousemove?: MouseEventHandler<T> | undefined | null;
	onmousemovecapture?: MouseEventHandler<T> | undefined | null;
	"on:mouseout"?: MouseEventHandler<T> | undefined | null;
	onmouseout?: MouseEventHandler<T> | undefined | null;
	onmouseoutcapture?: MouseEventHandler<T> | undefined | null;
	"on:mouseover"?: MouseEventHandler<T> | undefined | null;
	onmouseover?: MouseEventHandler<T> | undefined | null;
	onmouseovercapture?: MouseEventHandler<T> | undefined | null;
	"on:mouseup"?: MouseEventHandler<T> | undefined | null;
	onmouseup?: MouseEventHandler<T> | undefined | null;
	onmouseupcapture?: MouseEventHandler<T> | undefined | null;
	// Selection Events
	"on:select"?: EventHandler<Event, T> | undefined | null;
	onselect?: EventHandler<Event, T> | undefined | null;
	onselectcapture?: EventHandler<Event, T> | undefined | null;
	"on:selectionchange"?: EventHandler<Event, T> | undefined | null;
	onselectionchange?: EventHandler<Event, T> | undefined | null;
	onselectionchangecapture?: EventHandler<Event, T> | undefined | null;
	"on:selectstart"?: EventHandler<Event, T> | undefined | null;
	onselectstart?: EventHandler<Event, T> | undefined | null;
	onselectstartcapture?: EventHandler<Event, T> | undefined | null;
	// Touch Events
	"on:touchcancel"?: TouchEventHandler<T> | undefined | null;
	ontouchcancel?: TouchEventHandler<T> | undefined | null;
	ontouchcancelcapture?: TouchEventHandler<T> | undefined | null;
	"on:touchend"?: TouchEventHandler<T> | undefined | null;
	ontouchend?: TouchEventHandler<T> | undefined | null;
	ontouchendcapture?: TouchEventHandler<T> | undefined | null;
	"on:touchmove"?: TouchEventHandler<T> | undefined | null;
	ontouchmove?: TouchEventHandler<T> | undefined | null;
	ontouchmovecapture?: TouchEventHandler<T> | undefined | null;
	"on:touchstart"?: TouchEventHandler<T> | undefined | null;
	ontouchstart?: TouchEventHandler<T> | undefined | null;
	ontouchstartcapture?: TouchEventHandler<T> | undefined | null;
	// Pointer Events
	"on:gotpointercapture"?: PointerEventHandler<T> | undefined | null;
	ongotpointercapture?: PointerEventHandler<T> | undefined | null;
	ongotpointercapturecapture?: PointerEventHandler<T> | undefined | null;
	"on:pointercancel"?: PointerEventHandler<T> | undefined | null;
	onpointercancel?: PointerEventHandler<T> | undefined | null;
	onpointercancelcapture?: PointerEventHandler<T> | undefined | null;
	"on:pointerdown"?: PointerEventHandler<T> | undefined | null;
	onpointerdown?: PointerEventHandler<T> | undefined | null;
	onpointerdowncapture?: PointerEventHandler<T> | undefined | null;
	"on:pointerenter"?: PointerEventHandler<T> | undefined | null;
	onpointerenter?: PointerEventHandler<T> | undefined | null;
	onpointerentercapture?: PointerEventHandler<T> | undefined | null;
	"on:pointerleave"?: PointerEventHandler<T> | undefined | null;
	onpointerleave?: PointerEventHandler<T> | undefined | null;
	onpointerleavecapture?: PointerEventHandler<T> | undefined | null;
	"on:pointermove"?: PointerEventHandler<T> | undefined | null;
	onpointermove?: PointerEventHandler<T> | undefined | null;
	onpointermovecapture?: PointerEventHandler<T> | undefined | null;
	"on:pointerout"?: PointerEventHandler<T> | undefined | null;
	onpointerout?: PointerEventHandler<T> | undefined | null;
	onpointeroutcapture?: PointerEventHandler<T> | undefined | null;
	"on:pointerover"?: PointerEventHandler<T> | undefined | null;
	onpointerover?: PointerEventHandler<T> | undefined | null;
	onpointerovercapture?: PointerEventHandler<T> | undefined | null;
	"on:pointerup"?: PointerEventHandler<T> | undefined | null;
	onpointerup?: PointerEventHandler<T> | undefined | null;
	onpointerupcapture?: PointerEventHandler<T> | undefined | null;
	"on:lostpointercapture"?: PointerEventHandler<T> | undefined | null;
	onlostpointercapture?: PointerEventHandler<T> | undefined | null;
	onlostpointercapturecapture?: PointerEventHandler<T> | undefined | null;
	// Gamepad Events
	"on:gamepadconnected"?: GamepadEventHandler<T> | undefined | null;
	ongamepadconnected?: GamepadEventHandler<T> | undefined | null;
	"on:gamepaddisconnected"?: GamepadEventHandler<T> | undefined | null;
	ongamepaddisconnected?: GamepadEventHandler<T> | undefined | null;
	// UI Events
	"on:scroll"?: UIEventHandler<T> | undefined | null;
	onscroll?: UIEventHandler<T> | undefined | null;
	onscrollcapture?: UIEventHandler<T> | undefined | null;
	"on:scrollend"?: UIEventHandler<T> | undefined | null;
	onscrollend?: UIEventHandler<T> | undefined | null;
	onscrollendcapture?: UIEventHandler<T> | undefined | null;
	"on:resize"?: UIEventHandler<T> | undefined | null;
	onresize?: UIEventHandler<T> | undefined | null;
	onresizecapture?: UIEventHandler<T> | undefined | null;
	// Wheel Events
	"on:wheel"?: WheelEventHandler<T> | undefined | null;
	onwheel?: WheelEventHandler<T> | undefined | null;
	onwheelcapture?: WheelEventHandler<T> | undefined | null;
	// Animation Events
	"on:animationstart"?: AnimationEventHandler<T> | undefined | null;
	onanimationstart?: AnimationEventHandler<T> | undefined | null;
	onanimationstartcapture?: AnimationEventHandler<T> | undefined | null;
	"on:animationend"?: AnimationEventHandler<T> | undefined | null;
	onanimationend?: AnimationEventHandler<T> | undefined | null;
	onanimationendcapture?: AnimationEventHandler<T> | undefined | null;
	"on:animationiteration"?: AnimationEventHandler<T> | undefined | null;
	onanimationiteration?: AnimationEventHandler<T> | undefined | null;
	onanimationiterationcapture?: AnimationEventHandler<T> | undefined | null;
	// Transition Events
	"on:transitionstart"?: TransitionEventHandler<T> | undefined | null;
	ontransitionstart?: TransitionEventHandler<T> | undefined | null;
	ontransitionstartcapture?: TransitionEventHandler<T> | undefined | null;
	"on:transitionrun"?: TransitionEventHandler<T> | undefined | null;
	ontransitionrun?: TransitionEventHandler<T> | undefined | null;
	ontransitionruncapture?: TransitionEventHandler<T> | undefined | null;
	"on:transitionend"?: TransitionEventHandler<T> | undefined | null;
	ontransitionend?: TransitionEventHandler<T> | undefined | null;
	ontransitionendcapture?: TransitionEventHandler<T> | undefined | null;
	"on:transitioncancel"?: TransitionEventHandler<T> | undefined | null;
	ontransitioncancel?: TransitionEventHandler<T> | undefined | null;
	ontransitioncancelcapture?: TransitionEventHandler<T> | undefined | null;
	// Svelte Transition Events
	"on:outrostart"?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onoutrostart?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onoutrostartcapture?: EventHandler<CustomEvent<null>, T> | undefined | null;
	"on:outroend"?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onoutroend?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onoutroendcapture?: EventHandler<CustomEvent<null>, T> | undefined | null;
	"on:introstart"?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onintrostart?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onintrostartcapture?: EventHandler<CustomEvent<null>, T> | undefined | null;
	"on:introend"?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onintroend?: EventHandler<CustomEvent<null>, T> | undefined | null;
	onintroendcapture?: EventHandler<CustomEvent<null>, T> | undefined | null;
	// Message Events
	"on:message"?: MessageEventHandler<T> | undefined | null;
	onmessage?: MessageEventHandler<T> | undefined | null;
	onmessagecapture?: MessageEventHandler<T> | undefined | null;
	"on:messageerror"?: MessageEventHandler<T> | undefined | null;
	onmessageerror?: MessageEventHandler<T> | undefined | null;
	onmessageerrorcapture?: MessageEventHandler<T> | undefined | null;
	// Document Events
	"on:visibilitychange"?: EventHandler<Event, T> | undefined | null;
	onvisibilitychange?: EventHandler<Event, T> | undefined | null;
	onvisibilitychangecapture?: EventHandler<Event, T> | undefined | null;
	// Global Events
	"on:beforematch"?: EventHandler<Event, T> | undefined | null;
	onbeforematch?: EventHandler<Event, T> | undefined | null;
	onbeforematchcapture?: EventHandler<Event, T> | undefined | null;
	"on:cancel"?: EventHandler<Event, T> | undefined | null;
	oncancel?: EventHandler<Event, T> | undefined | null;
	oncancelcapture?: EventHandler<Event, T> | undefined | null;
	"on:close"?: EventHandler<Event, T> | undefined | null;
	onclose?: EventHandler<Event, T> | undefined | null;
	onclosecapture?: EventHandler<Event, T> | undefined | null;
	"on:fullscreenchange"?: EventHandler<Event, T> | undefined | null;
	onfullscreenchange?: EventHandler<Event, T> | undefined | null;
	onfullscreenchangecapture?: EventHandler<Event, T> | undefined | null;
	"on:fullscreenerror"?: EventHandler<Event, T> | undefined | null;
	onfullscreenerror?: EventHandler<Event, T> | undefined | null;
	onfullscreenerrorcapture?: EventHandler<Event, T> | undefined | null;
	// Dimensions
	readonly "bind:contentRect"?: DOMRectReadOnly | undefined | null;
	readonly "bind:contentBoxSize"?: Array<ResizeObserverSize> | undefined | null;
	readonly "bind:borderBoxSize"?: Array<ResizeObserverSize> | undefined | null;
	readonly "bind:devicePixelContentBoxSize"?: Array<ResizeObserverSize> | undefined | null;
	readonly "bind:clientWidth"?: number | undefined | null;
	readonly "bind:clientHeight"?: number | undefined | null;
	xmlns?: string | undefined | null;
}
// All the WAI-ARIA 1.1 attributes from https://www.w3.org/TR/wai-aria-1.1/
export interface AriaAttributes {
	/** Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application. */
	"aria-activedescendant"?: string | undefined | null;
	/** Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute. */
	"aria-atomic"?: Booleanish | undefined | null;
	/**
	 * Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be
	 * presented if they are made.
	 */
	"aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | null;
	/** Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user. */
	"aria-busy"?: Booleanish | undefined | null;
	/**
	 * Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.
	 * @see aria-pressed @see aria-selected.
	 */
	"aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | null;
	/**
	 * Defines the total number of columns in a table, grid, or treegrid.
	 * @see aria-colindex.
	 */
	"aria-colcount"?: number | undefined | null;
	/**
	 * Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.
	 * @see aria-colcount @see aria-colspan.
	 */
	"aria-colindex"?: number | undefined | null;
	/**
	 * Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.
	 * @see aria-colindex @see aria-rowspan.
	 */
	"aria-colspan"?: number | undefined | null;
	/**
	 * Identifies the element (or elements) whose contents or presence are controlled by the current element.
	 * @see aria-owns.
	 */
	"aria-controls"?: string | undefined | null;
	/** Indicates the element that represents the current item within a container or set of related elements. */
	"aria-current"?: Booleanish | "page" | "step" | "location" | "date" | "time" | undefined | null;
	/**
	 * Identifies the element (or elements) that describes the object.
	 * @see aria-labelledby
	 */
	"aria-describedby"?: string | undefined | null;
	/**
	 * Identifies the element that provides a detailed, extended description for the object.
	 * @see aria-describedby.
	 */
	"aria-details"?: string | undefined | null;
	/**
	 * Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.
	 * @see aria-hidden @see aria-readonly.
	 */
	"aria-disabled"?: Booleanish | undefined | null;
	/**
	 * Indicates what functions can be performed when a dragged object is released on the drop target.
	 * @deprecated in ARIA 1.1
	 */
	"aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | null;
	/**
	 * Identifies the element that provides an error message for the object.
	 * @see aria-invalid @see aria-describedby.
	 */
	"aria-errormessage"?: string | undefined | null;
	/** Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed. */
	"aria-expanded"?: Booleanish | undefined | null;
	/**
	 * Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion,
	 * allows assistive technology to override the general default of reading in document source order.
	 */
	"aria-flowto"?: string | undefined | null;
	/**
	 * Indicates an element's "grabbed" state in a drag-and-drop operation.
	 * @deprecated in ARIA 1.1
	 */
	"aria-grabbed"?: Booleanish | undefined | null;
	/** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. */
	"aria-haspopup"?: Booleanish | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | null;
	/**
	 * Indicates whether the element is exposed to an accessibility API.
	 * @see aria-disabled.
	 */
	"aria-hidden"?: Booleanish | undefined | null;
	/**
	 * Indicates the entered value does not conform to the format expected by the application.
	 * @see aria-errormessage.
	 */
	"aria-invalid"?: Booleanish | "grammar" | "spelling" | undefined | null;
	/** Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. */
	"aria-keyshortcuts"?: string | undefined | null;
	/**
	 * Defines a string value that labels the current element.
	 * @see aria-labelledby.
	 */
	"aria-label"?: string | undefined | null;
	/**
	 * Identifies the element (or elements) that labels the current element.
	 * @see aria-describedby.
	 */
	"aria-labelledby"?: string | undefined | null;
	/** Defines the hierarchical level of an element within a structure. */
	"aria-level"?: number | undefined | null;
	/** Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region. */
	"aria-live"?: "off" | "assertive" | "polite" | undefined | null;
	/** Indicates whether an element is modal when displayed. */
	"aria-modal"?: Booleanish | undefined | null;
	/** Indicates whether a text box accepts multiple lines of input or only a single line. */
	"aria-multiline"?: Booleanish | undefined | null;
	/** Indicates that the user may select more than one item from the current selectable descendants. */
	"aria-multiselectable"?: Booleanish | undefined | null;
	/** Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. */
	"aria-orientation"?: "horizontal" | "vertical" | undefined | null;
	/**
	 * Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship
	 * between DOM elements where the DOM hierarchy cannot be used to represent the relationship.
	 * @see aria-controls.
	 */
	"aria-owns"?: string | undefined | null;
	/**
	 * Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value.
	 * A hint could be a sample value or a brief description of the expected format.
	 */
	"aria-placeholder"?: string | undefined | null;
	/**
	 * Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
	 * @see aria-setsize.
	 */
	"aria-posinset"?: number | undefined | null;
	/**
	 * Indicates the current "pressed" state of toggle buttons.
	 * @see aria-checked @see aria-selected.
	 */
	"aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | null;
	/**
	 * Indicates that the element is not editable, but is otherwise operable.
	 * @see aria-disabled.
	 */
	"aria-readonly"?: Booleanish | undefined | null;
	/**
	 * Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.
	 * @see aria-atomic.
	 */
	"aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | null;
	/** Indicates that user input is required on the element before a form may be submitted. */
	"aria-required"?: Booleanish | undefined | null;
	/** Defines a human-readable, author-localized description for the role of an element. */
	"aria-roledescription"?: string | undefined | null;
	/**
	 * Defines the total number of rows in a table, grid, or treegrid.
	 * @see aria-rowindex.
	 */
	"aria-rowcount"?: number | undefined | null;
	/**
	 * Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.
	 * @see aria-rowcount @see aria-rowspan.
	 */
	"aria-rowindex"?: number | undefined | null;
	/**
	 * Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.
	 * @see aria-rowindex @see aria-colspan.
	 */
	"aria-rowspan"?: number | undefined | null;
	/**
	 * Indicates the current "selected" state of various widgets.
	 * @see aria-checked @see aria-pressed.
	 */
	"aria-selected"?: Booleanish | undefined | null;
	/**
	 * Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
	 * @see aria-posinset.
	 */
	"aria-setsize"?: number | undefined | null;
	/** Indicates if items in a table or grid are sorted in ascending or descending order. */
	"aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | null;
	/** Defines the maximum allowed value for a range widget. */
	"aria-valuemax"?: number | undefined | null;
	/** Defines the minimum allowed value for a range widget. */
	"aria-valuemin"?: number | undefined | null;
	/**
	 * Defines the current value for a range widget.
	 * @see aria-valuetext.
	 */
	"aria-valuenow"?: number | undefined | null;
	/** Defines the human readable text alternative of aria-valuenow for a range widget. */
	"aria-valuetext"?: string | undefined | null;
}
// All the WAI-ARIA 1.1 role attribute values from https://www.w3.org/TR/wai-aria-1.1/#role_definitions
export type AriaRole = "alert" | "alertdialog" | "application" | "article" | "banner" | "button" | "cell" | "checkbox" | "columnheader" | "combobox" | "complementary" | "contentinfo" | "definition" | "dialog" | "directory" | "document" | "feed" | "figure" | "form" | "grid" | "gridcell" | "group" | "heading" | "img" | "link" | "list" | "listbox" | "listitem" | "log" | "main" | "marquee" | "math" | "menu" | "menubar" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "navigation" | "none" | "note" | "option" | "presentation" | "progressbar" | "radio" | "radiogroup" | "region" | "row" | "rowgroup" | "rowheader" | "scrollbar" | "search" | "searchbox" | "separator" | "slider" | "spinbutton" | "status" | "switch" | "tab" | "table" | "tablist" | "tabpanel" | "term" | "textbox" | "timer" | "toolbar" | "tooltip" | "tree" | "treegrid" | "treeitem" | (string & {});
export interface HTMLAttributes<T extends EventTarget> extends AriaAttributes, DOMAttributes<T> {
	// Standard HTML Attributes
	accesskey?: string | undefined | null;
	autocapitalize?: "characters" | "off" | "on" | "none" | "sentences" | "words" | undefined | null;
	autofocus?: boolean | undefined | null;
	class?: ClassValue | undefined | null;
	contenteditable?: Booleanish | "inherit" | "plaintext-only" | undefined | null;
	contextmenu?: string | undefined | null;
	dir?: "ltr" | "rtl" | "auto" | undefined | null;
	draggable?: Booleanish | undefined | null;
	elementtiming?: string | undefined | null;
	enterkeyhint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | null;
	hidden?: boolean | "until-found" | "" | undefined | null;
	id?: string | undefined | null;
	lang?: string | undefined | null;
	part?: string | undefined | null;
	placeholder?: string | undefined | null;
	slot?: string | undefined | null;
	spellcheck?: Booleanish | undefined | null;
	style?: string | undefined | null;
	tabindex?: number | undefined | null;
	title?: string | undefined | null;
	translate?: "yes" | "no" | "" | undefined | null;
	inert?: boolean | undefined | null;
	popover?: "auto" | "manual" | "hint" | "" | undefined | null;
	writingsuggestions?: Booleanish | undefined | null;
	// Unknown
	radiogroup?: string | undefined | null; // <command>, <menuitem>
	// WAI-ARIA
	role?: AriaRole | undefined | null;
	// RDFa Attributes
	about?: string | undefined | null;
	datatype?: string | undefined | null;
	inlist?: any;
	prefix?: string | undefined | null;
	property?: string | undefined | null;
	resource?: string | undefined | null;
	typeof?: string | undefined | null;
	vocab?: string | undefined | null;
	// Non-standard Attributes
	autosave?: string | undefined | null;
	color?: string | undefined | null;
	itemprop?: string | undefined | null;
	itemscope?: boolean | undefined | null;
	itemtype?: string | undefined | null;
	itemid?: string | undefined | null;
	itemref?: string | undefined | null;
	results?: number | undefined | null;
	security?: string | undefined | null;
	unselectable?: "on" | "off" | undefined | null;
	// Living Standard
	/**
	 * Hints at the type of data that might be entered by the user while editing the element or its contents
	 * @see https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute
	 */
	inputmode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | null;
	/**
	 * Specify that a standard HTML element should behave like a defined custom built-in element
	 * @see https://html.spec.whatwg.org/multipage/custom-elements.html#attr-is
	 */
	is?: string | undefined | null;
	/**
	 * Elements with the contenteditable attribute support `innerHTML`, `textContent` and `innerText` bindings.
	 */
	"bind:innerHTML"?: string | undefined | null;
	/**
	 * Elements with the contenteditable attribute support `innerHTML`, `textContent` and `innerText` bindings.
	 */
	"bind:textContent"?: string | undefined | null;
	/**
	 * Elements with the contenteditable attribute support `innerHTML`, `textContent` and `innerText` bindings.
	 */
	"bind:innerText"?: string | undefined | null;
	readonly "bind:focused"?: boolean | undefined | null;
	readonly "bind:offsetWidth"?: number | undefined | null;
	readonly "bind:offsetHeight"?: number | undefined | null;
	// allow any data- attribute
	[key: `data-${string}`]: any;
	// allow any attachment and falsy values (by using false we prevent the usage of booleans values by themselves)
	[key: symbol]: Attachment<T> | false | undefined | null;
}
export type HTMLAttributeAnchorTarget = "_self" | "_blank" | "_parent" | "_top" | (string & {});
export interface HTMLAnchorAttributes extends HTMLAttributes<HTMLAnchorElement> {
	download?: any;
	href?: string | undefined | null;
	hreflang?: string | undefined | null;
	media?: string | undefined | null;
	ping?: string | undefined | null;
	rel?: string | undefined | null;
	target?: HTMLAttributeAnchorTarget | undefined | null;
	type?: string | undefined | null;
	referrerpolicy?: ReferrerPolicy | undefined | null;
}
export interface HTMLAudioAttributes extends HTMLMediaAttributes<HTMLAudioElement> {
}
export interface HTMLAreaAttributes extends HTMLAttributes<HTMLAreaElement> {
	alt?: string | undefined | null;
	coords?: string | undefined | null;
	download?: any;
	href?: string | undefined | null;
	hreflang?: string | undefined | null;
	media?: string | undefined | null;
	referrerpolicy?: ReferrerPolicy | undefined | null;
	rel?: string | undefined | null;
	shape?: "circle" | "default" | "poly" | "rect" | undefined | null;
	target?: string | undefined | null;
	ping?: string | undefined | null;
}
export interface HTMLBaseAttributes extends HTMLAttributes<HTMLBaseElement> {
	href?: string | undefined | null;
	target?: string | undefined | null;
}
export interface HTMLBlockquoteAttributes extends HTMLAttributes<HTMLQuoteElement> {
	cite?: string | undefined | null;
}
export interface HTMLButtonAttributes extends HTMLAttributes<HTMLButtonElement> {
	disabled?: boolean | undefined | null;
	form?: string | undefined | null;
	formaction?: string | undefined | null;
	formenctype?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain" | undefined | null;
	formmethod?: "dialog" | "get" | "post" | "DIALOG" | "GET" | "POST" | undefined | null;
	formnovalidate?: boolean | undefined | null;
	formtarget?: string | undefined | null;
	name?: string | undefined | null;
	type?: "submit" | "reset" | "button" | undefined | null;
	value?: string | string[] | number | undefined | null;
	popovertarget?: string | undefined | null;
	popovertargetaction?: "toggle" | "show" | "hide" | undefined | null;
	command?: "show-modal" | "close" | "request-close" | "show-popover" | "hide-popover" | "toggle-popover" | (string & {}) | undefined | null;
	commandfor?: string | undefined | null;
}
export interface HTMLCanvasAttributes extends HTMLAttributes<HTMLCanvasElement> {
	height?: number | string | undefined | null;
	width?: number | string | undefined | null;
}
export interface HTMLColAttributes extends HTMLAttributes<HTMLTableColElement> {
	span?: number | undefined | null;
	width?: number | string | undefined | null;
}
export interface HTMLColgroupAttributes extends HTMLAttributes<HTMLTableColElement> {
	span?: number | undefined | null;
}
export interface HTMLDataAttributes extends HTMLAttributes<HTMLDataElement> {
	value?: string | string[] | number | undefined | null;
}
export interface HTMLDetailsAttributes extends HTMLAttributes<HTMLDetailsElement> {
	open?: boolean | undefined | null;
	name?: string | undefined | null;
	"bind:open"?: boolean | undefined | null;
	"on:toggle"?: EventHandler<Event, HTMLDetailsElement> | undefined | null;
	ontoggle?: EventHandler<Event, HTMLDetailsElement> | undefined | null;
	ontogglecapture?: EventHandler<Event, HTMLDetailsElement> | undefined | null;
}
export interface HTMLDelAttributes extends HTMLAttributes<HTMLModElement> {
	cite?: string | undefined | null;
	datetime?: string | undefined | null;
}
export interface HTMLDialogAttributes extends HTMLAttributes<HTMLDialogElement> {
	open?: boolean | undefined | null;
	closedby?: "any" | "closerequest" | "none" | undefined | null;
}
export interface HTMLEmbedAttributes extends HTMLAttributes<HTMLEmbedElement> {
	height?: number | string | undefined | null;
	src?: string | undefined | null;
	type?: string | undefined | null;
	width?: number | string | undefined | null;
}
export interface HTMLFieldsetAttributes extends HTMLAttributes<HTMLFieldSetElement> {
	disabled?: boolean | undefined | null;
	form?: string | undefined | null;
	name?: string | undefined | null;
}
export interface HTMLFormAttributes extends HTMLAttributes<HTMLFormElement> {
	"accept-charset"?: "utf-8" | (string & {}) | undefined | null;
	action?: string | undefined | null;
	autocomplete?: AutoFillBase | undefined | null;
	enctype?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain" | undefined | null;
	method?: "dialog" | "get" | "post" | "DIALOG" | "GET" | "POST" | undefined | null;
	name?: string | undefined | null;
	novalidate?: boolean | undefined | null;
	target?: string | undefined | null;
	rel?: string | undefined | null;
}
export interface HTMLHtmlAttributes extends HTMLAttributes<HTMLHtmlElement> {
	manifest?: string | undefined | null;
}
export interface HTMLIframeAttributes extends HTMLAttributes<HTMLIFrameElement> {
	allow?: string | undefined | null;
	allowfullscreen?: boolean | undefined | null;
	allowtransparency?: boolean | undefined | null;
	/** @deprecated */
	frameborder?: number | string | undefined | null;
	height?: number | string | undefined | null;
	loading?: "eager" | "lazy" | undefined | null;
	/** @deprecated */
	marginheight?: number | undefined | null;
	/** @deprecated */
	marginwidth?: number | undefined | null;
	name?: string | undefined | null;
	referrerpolicy?: ReferrerPolicy | undefined | null;
	sandbox?: string | undefined | null;
	/** @deprecated */
	scrolling?: string | undefined | null;
	seamless?: boolean | undefined | null;
	src?: string | undefined | null;
	srcdoc?: string | undefined | null;
	width?: number | string | undefined | null;
}
export interface HTMLImgAttributes extends HTMLAttributes<HTMLImageElement> {
	alt?: string | undefined | null;
	crossorigin?: "anonymous" | "use-credentials" | "" | undefined | null;
	decoding?: "async" | "auto" | "sync" | undefined | null;
	fetchpriority?: "auto" | "high" | "low" | undefined | null;
	height?: number | string | undefined | null;
	ismap?: boolean | undefined | null;
	loading?: "eager" | "lazy" | undefined | null;
	referrerpolicy?: ReferrerPolicy | undefined | null;
	sizes?: string | undefined | null;
	src?: string | undefined | null;
	srcset?: string | undefined | null;
	usemap?: string | undefined | null;
	width?: number | string | undefined | null;
	readonly "bind:naturalWidth"?: number | undefined | null;
	readonly "bind:naturalHeight"?: number | undefined | null;
}
export interface HTMLInsAttributes extends HTMLAttributes<HTMLModElement> {
	cite?: string | undefined | null;
	datetime?: string | undefined | null;
}
export type HTMLInputTypeAttribute = "button" | "checkbox" | "color" | "date" | "datetime-local" | "email" | "file" | "hidden" | "image" | "month" | "number" | "password" | "radio" | "range" | "reset" | "search" | "submit" | "tel" | "text" | "time" | "url" | "week" | (string & {});
export interface HTMLInputAttributes extends HTMLAttributes<HTMLInputElement> {
	accept?: string | undefined | null;
	alt?: string | undefined | null;
	autocomplete?: FullAutoFill | undefined | null;
	// Safari only https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#autocorrect
	autocorrect?: "on" | "off" | "" | undefined | null;
	capture?: boolean | "user" | "environment" | undefined | null; // https://www.w3.org/TR/html-media-capture/#the-capture-attribute
	checked?: boolean | undefined | null;
	dirname?: string | undefined | null;
	disabled?: boolean | undefined | null;
	files?: FileList | undefined | null;
	form?: string | undefined | null;
	formaction?: string | undefined | null;
	formenctype?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain" | undefined | null;
	formmethod?: "dialog" | "get" | "post" | "DIALOG" | "GET" | "POST" | undefined | null;
	formnovalidate?: boolean | undefined | null;
	formtarget?: string | undefined | null;
	group?: any | undefined | null;
	height?: number | string | undefined | null;
	indeterminate?: boolean | undefined | null;
	list?: string | undefined | null;
	max?: number | string | undefined | null;
	maxlength?: number | undefined | null;
	min?: number | string | undefined | null;
	minlength?: number | undefined | null;
	multiple?: boolean | undefined | null;
	name?: string | undefined | null;
	pattern?: string | undefined | null;
	placeholder?: string | undefined | null;
	readonly?: boolean | undefined | null;
	required?: boolean | undefined | null;
	size?: number | undefined | null;
	src?: string | undefined | null;
	step?: number | string | undefined | null;
	type?: HTMLInputTypeAttribute | undefined | null;
	value?: any;
	// needs both casing variants because language tools does lowercase names of non-shorthand attributes
	defaultValue?: any;
	defaultvalue?: any;
	defaultChecked?: boolean | undefined | null;
	defaultchecked?: boolean | undefined | null;
	width?: number | string | undefined | null;
	webkitdirectory?: boolean | undefined | null;
	"on:change"?: ChangeEventHandler<HTMLInputElement> | undefined | null;
	onchange?: ChangeEventHandler<HTMLInputElement> | undefined | null;
	"bind:checked"?: boolean | undefined | null;
	"bind:value"?: any;
	"bind:group"?: any | undefined | null;
	"bind:files"?: FileList | undefined | null;
	"bind:indeterminate"?: boolean | undefined | null;
}
export interface HTMLKeygenAttributes extends HTMLAttributes<HTMLElement> {
	challenge?: string | undefined | null;
	disabled?: boolean | undefined | null;
	form?: string | undefined | null;
	keytype?: string | undefined | null;
	keyparams?: string | undefined | null;
	name?: string | undefined | null;
}
export interface HTMLLabelAttributes extends HTMLAttributes<HTMLLabelElement> {
	form?: string | undefined | null;
	for?: string | undefined | null;
}
export interface HTMLLiAttributes extends HTMLAttributes<HTMLLIElement> {
	value?: string | string[] | number | undefined | null;
}
export interface HTMLLinkAttributes extends HTMLAttributes<HTMLLinkElement> {
	as?: "fetch" | "audio" | "audioworklet" | "document" | "embed" | "font" | "frame" | "iframe" | "image" | "json" | "manifest" | "object" | "paintworklet" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "track" | "video" | "webidentity" | "worker" | "xslt" | "" | undefined | null;
	crossorigin?: "anonymous" | "use-credentials" | "" | undefined | null;
	href?: string | undefined | null;
	hreflang?: string | undefined | null;
	integrity?: string | undefined | null;
	media?: string | undefined | null;
	imagesrcset?: string | undefined | null;
	imagesizes?: string | undefined | null;
	referrerpolicy?: ReferrerPolicy | undefined | null;
	rel?: string | undefined | null;
	sizes?: string | undefined | null;
	type?: string | undefined | null;
	charset?: string | undefined | null;
	fetchpriority?: "auto" | "high" | "low" | undefined | null;
}
export interface HTMLMapAttributes extends HTMLAttributes<HTMLMapElement> {
	name?: string | undefined | null;
}
export interface HTMLMenuAttributes extends HTMLAttributes<HTMLMenuElement> {
	type?: string | undefined | null;
}
export interface HTMLMediaAttributes<T extends HTMLMediaElement> extends HTMLAttributes<T> {
	autoplay?: boolean | undefined | null;
	controls?: boolean | undefined | null;
	controlslist?: "nodownload" | "nofullscreen" | "noplaybackrate" | "noremoteplayback" | (string & {}) | undefined | null;
	crossorigin?: "anonymous" | "use-credentials" | "" | undefined | null;
	currenttime?: number | undefined | null;
	defaultmuted?: boolean | undefined | null;
	defaultplaybackrate?: number | undefined | null;
	loop?: boolean | undefined | null;
	mediagroup?: string | undefined | null;
	muted?: boolean | undefined | null;
	playsinline?: boolean | undefined | null;
	preload?: "auto" | "none" | "metadata" | "" | undefined | null;
	src?: string | undefined | null;
	srcobject?: MediaStream | MediaSource | File | Blob;
	/**
	 * a value between 0 and 1
	 */
	volume?: number | undefined | null;
	readonly "bind:readyState"?: 0 | 1 | 2 | 3 | 4 | undefined | null;
	readonly "bind:duration"?: number | undefined | null;
	readonly "bind:buffered"?: SvelteMediaTimeRange[] | undefined | null;
	readonly "bind:played"?: SvelteMediaTimeRange[] | undefined | null;
	readonly "bind:seekable"?: SvelteMediaTimeRange[] | undefined | null;
	readonly "bind:seeking"?: boolean | undefined | null;
	readonly "bind:ended"?: boolean | undefined | null;
	"bind:muted"?: boolean | undefined | null;
	"bind:volume"?: number | undefined | null;
	/**
	 * the current playback time in the video, in seconds
	 */
	"bind:currentTime"?: number | undefined | null;
	/**
	 * how fast or slow to play the video, where 1 is 'normal'
	 */
	"bind:playbackRate"?: number | undefined | null;
	"bind:paused"?: boolean | undefined | null;
}
export interface HTMLMetaAttributes extends HTMLAttributes<HTMLMetaElement> {
	charset?: string | undefined | null;
	content?: string | undefined | null;
	"http-equiv"?: "accept-ch" | "content-security-policy" | "content-type" | "default-style" | "refresh" | "x-ua-compatible" | undefined | null;
	name?: string | undefined | null;
	media?: string | undefined | null;
}
export interface HTMLMeterAttributes extends HTMLAttributes<HTMLMeterElement> {
	form?: string | undefined | null;
	high?: number | undefined | null;
	low?: number | undefined | null;
	max?: number | string | undefined | null;
	min?: number | string | undefined | null;
	optimum?: number | undefined | null;
	value?: string | string[] | number | undefined | null;
}
export interface HTMLQuoteAttributes extends HTMLAttributes<HTMLQuoteElement> {
	cite?: string | undefined | null;
}
export interface HTMLObjectAttributes extends HTMLAttributes<HTMLObjectElement> {
	classid?: string | undefined | null;
	data?: string | undefined | null;
	form?: string | undefined | null;
	height?: number | string | undefined | null;
	name?: string | undefined | null;
	type?: string | undefined | null;
	usemap?: string | undefined | null;
	width?: number | string | undefined | null;
	wmode?: string | undefined | null;
}
export interface HTMLOlAttributes extends HTMLAttributes<HTMLOListElement> {
	reversed?: boolean | undefined | null;
	start?: number | undefined | null;
	type?: "1" | "a" | "A" | "i" | "I" | undefined | null;
}
export interface HTMLOptgroupAttributes extends HTMLAttributes<HTMLOptGroupElement> {
	disabled?: boolean | undefined | null;
	label?: string | undefined | null;
}
export interface HTMLOptionAttributes extends HTMLAttributes<HTMLOptionElement> {
	disabled?: boolean | undefined | null;
	label?: string | undefined | null;
	selected?: boolean | undefined | null;
	value?: any;
}
export interface HTMLOutputAttributes extends HTMLAttributes<HTMLOutputElement> {
	form?: string | undefined | null;
	for?: string | undefined | null;
	name?: string | undefined | null;
}
export interface HTMLParamAttributes extends HTMLAttributes<HTMLParamElement> {
	name?: string | undefined | null;
	value?: string | string[] | number | undefined | null;
}
export interface HTMLProgressAttributes extends HTMLAttributes<HTMLProgressElement> {
	max?: number | string | undefined | null;
	value?: string | string[] | number | undefined | null;
}
export interface HTMLSlotAttributes extends HTMLAttributes<HTMLSlotElement> {
	name?: string | undefined | null;
}
export interface HTMLScriptAttributes extends HTMLAttributes<HTMLScriptElement> {
	async?: boolean | undefined | null;
	/** @deprecated */
	charset?: string | undefined | null;
	crossorigin?: "anonymous" | "use-credentials" | "" | undefined | null;
	defer?: boolean | undefined | null;
	fetchpriority?: "auto" | "high" | "low" | undefined | null;
	integrity?: string | undefined | null;
	nomodule?: boolean | undefined | null;
	nonce?: string | undefined | null;
	referrerpolicy?: ReferrerPolicy | undefined | null;
	src?: string | undefined | null;
	type?: string | undefined | null;
}
export interface HTMLSelectAttributes extends HTMLAttributes<HTMLSelectElement> {
	autocomplete?: FullAutoFill | undefined | null;
	disabled?: boolean | undefined | null;
	form?: string | undefined | null;
	multiple?: boolean | undefined | null;
	name?: string | undefined | null;
	required?: boolean | undefined | null;
	size?: number | undefined | null;
	value?: any;
	"on:change"?: ChangeEventHandler<HTMLSelectElement> | undefined | null;
	onchange?: ChangeEventHandler<HTMLSelectElement> | undefined | null;
	"bind:value"?: any;
}
export interface HTMLSourceAttributes extends HTMLAttributes<HTMLSourceElement> {
	height?: number | string | undefined | null;
	media?: string | undefined | null;
	sizes?: string | undefined | null;
	src?: string | undefined | null;
	srcset?: string | undefined | null;
	type?: string | undefined | null;
	width?: number | string | undefined | null;
}
export interface HTMLStyleAttributes extends HTMLAttributes<HTMLStyleElement> {
	media?: string | undefined | null;
	nonce?: string | undefined | null;
	scoped?: boolean | undefined | null;
	type?: string | undefined | null;
}
export interface HTMLTableAttributes extends HTMLAttributes<HTMLTableElement> {
	align?: "left" | "center" | "right" | undefined | null;
	bgcolor?: string | undefined | null;
	border?: number | undefined | null;
	cellpadding?: number | string | undefined | null;
	cellspacing?: number | string | undefined | null;
	frame?: boolean | undefined | null;
	rules?: "none" | "groups" | "rows" | "columns" | "all" | undefined | null;
	summary?: string | undefined | null;
	width?: number | string | undefined | null;
}
export interface HTMLTextareaAttributes extends HTMLAttributes<HTMLTextAreaElement> {
	autocomplete?: FullAutoFill | undefined | null;
	cols?: number | undefined | null;
	dirname?: string | undefined | null;
	disabled?: boolean | undefined | null;
	form?: string | undefined | null;
	maxlength?: number | undefined | null;
	minlength?: number | undefined | null;
	name?: string | undefined | null;
	placeholder?: string | undefined | null;
	readonly?: boolean | undefined | null;
	required?: boolean | undefined | null;
	rows?: number | undefined | null;
	value?: string | string[] | number | undefined | null;
	// needs both casing variants because language tools does lowercase names of non-shorthand attributes
	defaultValue?: string | string[] | number | undefined | null;
	defaultvalue?: string | string[] | number | undefined | null;
	wrap?: "hard" | "soft" | "off" | undefined | null;
	"on:change"?: ChangeEventHandler<HTMLTextAreaElement> | undefined | null;
	onchange?: ChangeEventHandler<HTMLTextAreaElement> | undefined | null;
	"bind:value"?: any;
}
export interface HTMLTdAttributes extends HTMLAttributes<HTMLTableCellElement> {
	align?: "left" | "center" | "right" | "justify" | "char" | undefined | null;
	colspan?: number | undefined | null;
	headers?: string | undefined | null;
	rowspan?: number | undefined | null;
	scope?: "col" | "colgroup" | "row" | "rowgroup" | undefined | null;
	abbr?: string | undefined | null;
	height?: number | string | undefined | null;
	width?: number | string | undefined | null;
	valign?: "top" | "middle" | "bottom" | "baseline" | undefined | null;
}
export interface HTMLThAttributes extends HTMLAttributes<HTMLTableCellElement> {
	align?: "left" | "center" | "right" | "justify" | "char" | undefined | null;
	colspan?: number | undefined | null;
	headers?: string | undefined | null;
	rowspan?: number | undefined | null;
	scope?: "col" | "colgroup" | "row" | "rowgroup" | undefined | null;
	abbr?: string | undefined | null;
}
export interface HTMLTimeAttributes extends HTMLAttributes<HTMLTimeElement> {
	datetime?: string | undefined | null;
}
export interface HTMLTrackAttributes extends HTMLAttributes<HTMLTrackElement> {
	default?: boolean | undefined | null;
	kind?: "captions" | "chapters" | "descriptions" | "metadata" | "subtitles" | undefined | null;
	label?: string | undefined | null;
	src?: string | undefined | null;
	srclang?: string | undefined | null;
}
export interface HTMLVideoAttributes extends HTMLMediaAttributes<HTMLVideoElement> {
	height?: number | string | undefined | null;
	playsinline?: boolean | undefined | null;
	poster?: string | undefined | null;
	width?: number | string | undefined | null;
	disablepictureinpicture?: boolean | undefined | null;
	disableremoteplayback?: boolean | undefined | null;
	readonly "bind:videoWidth"?: number | undefined | null;
	readonly "bind:videoHeight"?: number | undefined | null;
}
export interface SvelteMediaTimeRange {
	start: number;
	end: number;
}
export interface SvelteDocumentAttributes extends HTMLAttributes<Document> {
	readonly "bind:activeElement"?: Document["activeElement"] | undefined | null;
	readonly "bind:fullscreenElement"?: Document["fullscreenElement"] | undefined | null;
	readonly "bind:pointerLockElement"?: Document["pointerLockElement"] | undefined | null;
	readonly "bind:visibilityState"?: Document["visibilityState"] | undefined | null;
}
export interface SvelteWindowAttributes extends HTMLAttributes<Window> {
	readonly "bind:innerWidth"?: Window["innerWidth"] | undefined | null;
	readonly "bind:innerHeight"?: Window["innerHeight"] | undefined | null;
	readonly "bind:outerWidth"?: Window["outerWidth"] | undefined | null;
	readonly "bind:outerHeight"?: Window["outerHeight"] | undefined | null;
	readonly "bind:devicePixelRatio"?: Window["devicePixelRatio"] | undefined | null;
	"bind:scrollX"?: Window["scrollX"] | undefined | null;
	"bind:scrollY"?: Window["scrollY"] | undefined | null;
	readonly "bind:online"?: Window["navigator"]["onLine"] | undefined | null;
	"on:devicelight"?: EventHandler<Event, Window> | undefined | null;
	ondevicelight?: EventHandler<Event, Window> | undefined | null;
	"on:beforeinstallprompt"?: EventHandler<Event, Window> | undefined | null;
	onbeforeinstallprompt?: EventHandler<Event, Window> | undefined | null;
	"on:deviceproximity"?: EventHandler<Event, Window> | undefined | null;
	ondeviceproximity?: EventHandler<Event, Window> | undefined | null;
	"on:paint"?: EventHandler<Event, Window> | undefined | null;
	onpaint?: EventHandler<Event, Window> | undefined | null;
	"on:userproximity"?: EventHandler<Event, Window> | undefined | null;
	onuserproximity?: EventHandler<Event, Window> | undefined | null;
	"on:beforeprint"?: EventHandler<Event, Window> | undefined | null;
	onbeforeprint?: EventHandler<Event, Window> | undefined | null;
	"on:afterprint"?: EventHandler<Event, Window> | undefined | null;
	onafterprint?: EventHandler<Event, Window> | undefined | null;
	"on:languagechange"?: EventHandler<Event, Window> | undefined | null;
	onlanguagechange?: EventHandler<Event, Window> | undefined | null;
	"on:orientationchange"?: EventHandler<Event, Window> | undefined | null;
	onorientationchange?: EventHandler<Event, Window> | undefined | null;
	"on:message"?: EventHandler<MessageEvent, Window> | undefined | null;
	onmessage?: EventHandler<MessageEvent, Window> | undefined | null;
	"on:messageerror"?: EventHandler<MessageEvent, Window> | undefined | null;
	onmessageerror?: EventHandler<MessageEvent, Window> | undefined | null;
	"on:offline"?: EventHandler<Event, Window> | undefined | null;
	onoffline?: EventHandler<Event, Window> | undefined | null;
	"on:online"?: EventHandler<Event, Window> | undefined | null;
	ononline?: EventHandler<Event, Window> | undefined | null;
	"on:beforeunload"?: EventHandler<BeforeUnloadEvent, Window> | undefined | null;
	onbeforeunload?: EventHandler<BeforeUnloadEvent, Window> | undefined | null;
	"on:unload"?: EventHandler<Event, Window> | undefined | null;
	onunload?: EventHandler<Event, Window> | undefined | null;
	"on:storage"?: EventHandler<StorageEvent, Window> | undefined | null;
	onstorage?: EventHandler<StorageEvent, Window> | undefined | null;
	"on:hashchange"?: EventHandler<HashChangeEvent, Window> | undefined | null;
	onhashchange?: EventHandler<HashChangeEvent, Window> | undefined | null;
	"on:pagehide"?: EventHandler<PageTransitionEvent, Window> | undefined | null;
	onpagehide?: EventHandler<PageTransitionEvent, Window> | undefined | null;
	"on:pageshow"?: EventHandler<PageTransitionEvent, Window> | undefined | null;
	onpageshow?: EventHandler<PageTransitionEvent, Window> | undefined | null;
	"on:popstate"?: EventHandler<PopStateEvent, Window> | undefined | null;
	onpopstate?: EventHandler<PopStateEvent, Window> | undefined | null;
	"on:devicemotion"?: EventHandler<DeviceMotionEvent> | undefined | null;
	ondevicemotion?: EventHandler<DeviceMotionEvent> | undefined | null;
	"on:deviceorientation"?: EventHandler<DeviceOrientationEvent, Window> | undefined | null;
	ondeviceorientation?: EventHandler<DeviceOrientationEvent, Window> | undefined | null;
	"on:deviceorientationabsolute"?: EventHandler<DeviceOrientationEvent, Window> | undefined | null;
	ondeviceorientationabsolute?: EventHandler<DeviceOrientationEvent, Window> | undefined | null;
	"on:unhandledrejection"?: EventHandler<PromiseRejectionEvent, Window> | undefined | null;
	onunhandledrejection?: EventHandler<PromiseRejectionEvent, Window> | undefined | null;
	"on:rejectionhandled"?: EventHandler<PromiseRejectionEvent, Window> | undefined | null;
	onrejectionhandled?: EventHandler<PromiseRejectionEvent, Window> | undefined | null;
}
export interface SVGAttributes<T extends EventTarget> extends AriaAttributes, DOMAttributes<T> {
	// Attributes which also defined in HTMLAttributes
	className?: string | undefined | null;
	class?: ClassValue | undefined | null;
	color?: string | undefined | null;
	height?: number | string | undefined | null;
	id?: string | undefined | null;
	lang?: string | undefined | null;
	part?: string | undefined | null;
	max?: number | string | undefined | null;
	media?: string | undefined | null;
	// On the `textPath` element
	method?: "align" | "stretch" | undefined | null;
	min?: number | string | undefined | null;
	name?: string | undefined | null;
	style?: string | undefined | null;
	target?: string | undefined | null;
	type?: string | undefined | null;
	width?: number | string | undefined | null;
	// Other HTML properties supported by SVG elements in browsers
	role?: AriaRole | undefined | null;
	tabindex?: number | undefined | null;
	crossorigin?: "anonymous" | "use-credentials" | "" | undefined | null;
	// SVG Specific attributes
	"accent-height"?: number | string | undefined | null;
	accumulate?: "none" | "sum" | undefined | null;
	additive?: "replace" | "sum" | undefined | null;
	"alignment-baseline"?: "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit" | undefined | null;
	allowReorder?: "no" | "yes" | undefined | null;
	alphabetic?: number | string | undefined | null;
	amplitude?: number | string | undefined | null;
	"arabic-form"?: "initial" | "medial" | "terminal" | "isolated" | undefined | null;
	ascent?: number | string | undefined | null;
	attributeName?: string | undefined | null;
	attributeType?: string | undefined | null;
	autoReverse?: number | string | undefined | null;
	azimuth?: number | string | undefined | null;
	baseFrequency?: number | string | undefined | null;
	"baseline-shift"?: number | string | undefined | null;
	baseProfile?: number | string | undefined | null;
	bbox?: number | string | undefined | null;
	begin?: number | string | undefined | null;
	bias?: number | string | undefined | null;
	by?: number | string | undefined | null;
	calcMode?: number | string | undefined | null;
	"cap-height"?: number | string | undefined | null;
	clip?: number | string | undefined | null;
	"clip-path"?: string | undefined | null;
	clipPathUnits?: number | string | undefined | null;
	"clip-rule"?: number | string | undefined | null;
	"color-interpolation"?: number | string | undefined | null;
	"color-interpolation-filters"?: "auto" | "sRGB" | "linearRGB" | "inherit" | undefined | null;
	"color-profile"?: number | string | undefined | null;
	"color-rendering"?: number | string | undefined | null;
	contentScriptType?: number | string | undefined | null;
	contentStyleType?: number | string | undefined | null;
	cursor?: number | string | undefined | null;
	cx?: number | string | undefined | null;
	cy?: number | string | undefined | null;
	d?: string | undefined | null;
	decelerate?: number | string | undefined | null;
	descent?: number | string | undefined | null;
	diffuseConstant?: number | string | undefined | null;
	direction?: number | string | undefined | null;
	display?: number | string | undefined | null;
	divisor?: number | string | undefined | null;
	"dominant-baseline"?: number | string | undefined | null;
	dur?: number | string | undefined | null;
	dx?: number | string | undefined | null;
	dy?: number | string | undefined | null;
	edgeMode?: number | string | undefined | null;
	elevation?: number | string | undefined | null;
	"enable-background"?: number | string | undefined | null;
	end?: number | string | undefined | null;
	exponent?: number | string | undefined | null;
	externalResourcesRequired?: number | string | undefined | null;
	fill?: string | undefined | null;
	"fill-opacity"?: number | string | undefined | null;
	"fill-rule"?: "nonzero" | "evenodd" | "inherit" | undefined | null;
	filter?: string | undefined | null;
	filterRes?: number | string | undefined | null;
	filterUnits?: number | string | undefined | null;
	"flood-color"?: number | string | undefined | null;
	"flood-opacity"?: number | string | undefined | null;
	focusable?: number | string | undefined | null;
	"font-family"?: string | undefined | null;
	"font-size"?: number | string | undefined | null;
	"font-size-adjust"?: number | string | undefined | null;
	"font-stretch"?: number | string | undefined | null;
	"font-style"?: number | string | undefined | null;
	"font-variant"?: number | string | undefined | null;
	"font-weight"?: number | string | undefined | null;
	format?: number | string | undefined | null;
	fr?: number | string | undefined | null;
	from?: number | string | undefined | null;
	fx?: number | string | undefined | null;
	fy?: number | string | undefined | null;
	g1?: number | string | undefined | null;
	g2?: number | string | undefined | null;
	"glyph-name"?: number | string | undefined | null;
	"glyph-orientation-horizontal"?: number | string | undefined | null;
	"glyph-orientation-vertical"?: number | string | undefined | null;
	glyphRef?: number | string | undefined | null;
	gradientTransform?: string | undefined | null;
	gradientUnits?: string | undefined | null;
	hanging?: number | string | undefined | null;
	href?: string | undefined | null;
	"horiz-adv-x"?: number | string | undefined | null;
	"horiz-origin-x"?: number | string | undefined | null;
	ideographic?: number | string | undefined | null;
	"image-rendering"?: number | string | undefined | null;
	in2?: number | string | undefined | null;
	in?: string | undefined | null;
	intercept?: number | string | undefined | null;
	k1?: number | string | undefined | null;
	k2?: number | string | undefined | null;
	k3?: number | string | undefined | null;
	k4?: number | string | undefined | null;
	k?: number | string | undefined | null;
	kernelMatrix?: number | string | undefined | null;
	kernelUnitLength?: number | string | undefined | null;
	kerning?: number | string | undefined | null;
	keyPoints?: number | string | undefined | null;
	keySplines?: number | string | undefined | null;
	keyTimes?: number | string | undefined | null;
	lengthAdjust?: number | string | undefined | null;
	"letter-spacing"?: number | string | undefined | null;
	"lighting-color"?: number | string | undefined | null;
	limitingConeAngle?: number | string | undefined | null;
	local?: number | string | undefined | null;
	"marker-end"?: string | undefined | null;
	markerHeight?: number | string | undefined | null;
	"marker-mid"?: string | undefined | null;
	"marker-start"?: string | undefined | null;
	markerUnits?: number | string | undefined | null;
	markerWidth?: number | string | undefined | null;
	mask?: string | undefined | null;
	maskContentUnits?: number | string | undefined | null;
	maskUnits?: number | string | undefined | null;
	mathematical?: number | string | undefined | null;
	mode?: number | string | undefined | null;
	numOctaves?: number | string | undefined | null;
	offset?: number | string | undefined | null;
	opacity?: number | string | undefined | null;
	operator?: number | string | undefined | null;
	order?: number | string | undefined | null;
	orient?: number | string | undefined | null;
	orientation?: number | string | undefined | null;
	origin?: number | string | undefined | null;
	overflow?: number | string | undefined | null;
	"overline-position"?: number | string | undefined | null;
	"overline-thickness"?: number | string | undefined | null;
	"paint-order"?: number | string | undefined | null;
	"panose-1"?: number | string | undefined | null;
	path?: string | undefined | null;
	pathLength?: number | string | undefined | null;
	patternContentUnits?: string | undefined | null;
	patternTransform?: number | string | undefined | null;
	patternUnits?: string | undefined | null;
	"pointer-events"?: number | string | undefined | null;
	points?: string | undefined | null;
	pointsAtX?: number | string | undefined | null;
	pointsAtY?: number | string | undefined | null;
	pointsAtZ?: number | string | undefined | null;
	preserveAlpha?: number | string | undefined | null;
	preserveAspectRatio?: string | undefined | null;
	primitiveUnits?: number | string | undefined | null;
	r?: number | string | undefined | null;
	radius?: number | string | undefined | null;
	refX?: number | string | undefined | null;
	refY?: number | string | undefined | null;
	"rendering-intent"?: number | string | undefined | null;
	repeatCount?: number | string | undefined | null;
	repeatDur?: number | string | undefined | null;
	requiredExtensions?: number | string | undefined | null;
	requiredFeatures?: number | string | undefined | null;
	restart?: number | string | undefined | null;
	result?: string | undefined | null;
	rotate?: number | string | undefined | null;
	rx?: number | string | undefined | null;
	ry?: number | string | undefined | null;
	scale?: number | string | undefined | null;
	seed?: number | string | undefined | null;
	"shape-rendering"?: number | string | undefined | null;
	slope?: number | string | undefined | null;
	spacing?: number | string | undefined | null;
	specularConstant?: number | string | undefined | null;
	specularExponent?: number | string | undefined | null;
	speed?: number | string | undefined | null;
	spreadMethod?: string | undefined | null;
	startOffset?: number | string | undefined | null;
	stdDeviation?: number | string | undefined | null;
	stemh?: number | string | undefined | null;
	stemv?: number | string | undefined | null;
	stitchTiles?: number | string | undefined | null;
	"stop-color"?: string | undefined | null;
	"stop-opacity"?: number | string | undefined | null;
	"strikethrough-position"?: number | string | undefined | null;
	"strikethrough-thickness"?: number | string | undefined | null;
	string?: number | string | undefined | null;
	stroke?: string | undefined | null;
	"stroke-dasharray"?: string | number | undefined | null;
	"stroke-dashoffset"?: string | number | undefined | null;
	"stroke-linecap"?: "butt" | "round" | "square" | "inherit" | undefined | null;
	"stroke-linejoin"?: "arcs" | "miter-clip" | "miter" | "round" | "bevel" | "inherit" | undefined | null;
	"stroke-miterlimit"?: string | undefined | null;
	"stroke-opacity"?: number | string | undefined | null;
	"stroke-width"?: number | string | undefined | null;
	surfaceScale?: number | string | undefined | null;
	systemLanguage?: number | string | undefined | null;
	tableValues?: number | string | undefined | null;
	targetX?: number | string | undefined | null;
	targetY?: number | string | undefined | null;
	"text-anchor"?: string | undefined | null;
	"text-decoration"?: number | string | undefined | null;
	textLength?: number | string | undefined | null;
	"text-rendering"?: number | string | undefined | null;
	to?: number | string | undefined | null;
	transform?: string | undefined | null;
	"transform-origin"?: string | undefined | null;
	u1?: number | string | undefined | null;
	u2?: number | string | undefined | null;
	"underline-position"?: number | string | undefined | null;
	"underline-thickness"?: number | string | undefined | null;
	unicode?: number | string | undefined | null;
	"unicode-bidi"?: number | string | undefined | null;
	"unicode-range"?: number | string | undefined | null;
	"units-per-em"?: number | string | undefined | null;
	"v-alphabetic"?: number | string | undefined | null;
	values?: string | undefined | null;
	"vector-effect"?: number | string | undefined | null;
	version?: string | undefined | null;
	"vert-adv-y"?: number | string | undefined | null;
	"vert-origin-x"?: number | string | undefined | null;
	"vert-origin-y"?: number | string | undefined | null;
	"v-hanging"?: number | string | undefined | null;
	"v-ideographic"?: number | string | undefined | null;
	viewBox?: string | undefined | null;
	viewTarget?: number | string | undefined | null;
	visibility?: number | string | undefined | null;
	"v-mathematical"?: number | string | undefined | null;
	widths?: number | string | undefined | null;
	"word-spacing"?: number | string | undefined | null;
	"writing-mode"?: number | string | undefined | null;
	x1?: number | string | undefined | null;
	x2?: number | string | undefined | null;
	x?: number | string | undefined | null;
	xChannelSelector?: string | undefined | null;
	"x-height"?: number | string | undefined | null;
	"xlink:actuate"?: string | undefined | null;
	"xlink:arcrole"?: string | undefined | null;
	"xlink:href"?: string | undefined | null;
	"xlink:role"?: string | undefined | null;
	"xlink:show"?: string | undefined | null;
	"xlink:title"?: string | undefined | null;
	"xlink:type"?: string | undefined | null;
	"xml:base"?: string | undefined | null;
	"xml:lang"?: string | undefined | null;
	"xmlns:xlink"?: string | undefined | null;
	"xml:space"?: string | undefined | null;
	y1?: number | string | undefined | null;
	y2?: number | string | undefined | null;
	y?: number | string | undefined | null;
	yChannelSelector?: string | undefined | null;
	z?: number | string | undefined | null;
	zoomAndPan?: string | undefined | null;
	// allow any data- attribute
	[key: `data-${string}`]: any;
}
export interface HTMLTemplateAttributes extends HTMLAttributes<HTMLElement> {
	shadowrootmode?: "open" | "closed" | undefined | null;
}
export interface HTMLWebViewAttributes extends HTMLAttributes<HTMLElement> {
	allowfullscreen?: boolean | undefined | null;
	allowpopups?: boolean | undefined | null;
	autosize?: boolean | undefined | null;
	blinkfeatures?: string | undefined | null;
	disableblinkfeatures?: string | undefined | null;
	disableguestresize?: boolean | undefined | null;
	disablewebsecurity?: boolean | undefined | null;
	guestinstance?: string | undefined | null;
	httpreferrer?: string | undefined | null;
	nodeintegration?: boolean | undefined | null;
	partition?: string | undefined | null;
	plugins?: boolean | undefined | null;
	preload?: string | undefined | null; // in the DOM it's only 'auto' | 'none' | 'metadata' | '', but electron allows arbitrary values
	src?: string | undefined | null;
	useragent?: string | undefined | null;
	webpreferences?: string | undefined | null;
}
//
// DOM Elements
// ----------------------------------------------------------------------
export interface SvelteHTMLElements {
	a: HTMLAnchorAttributes;
	abbr: HTMLAttributes<HTMLElement>;
	address: HTMLAttributes<HTMLElement>;
	area: HTMLAreaAttributes;
	article: HTMLAttributes<HTMLElement>;
	aside: HTMLAttributes<HTMLElement>;
	audio: HTMLAudioAttributes;
	b: HTMLAttributes<HTMLElement>;
	base: HTMLBaseAttributes;
	bdi: HTMLAttributes<HTMLElement>;
	bdo: HTMLAttributes<HTMLElement>;
	big: HTMLAttributes<HTMLElement>;
	blockquote: HTMLBlockquoteAttributes;
	body: HTMLAttributes<HTMLBodyElement>;
	br: HTMLAttributes<HTMLBRElement>;
	button: HTMLButtonAttributes;
	canvas: HTMLCanvasAttributes;
	caption: HTMLAttributes<HTMLElement>;
	cite: HTMLAttributes<HTMLElement>;
	code: HTMLAttributes<HTMLElement>;
	col: HTMLColAttributes;
	colgroup: HTMLColgroupAttributes;
	data: HTMLDataAttributes;
	datalist: HTMLAttributes<HTMLDataListElement>;
	dd: HTMLAttributes<HTMLElement>;
	del: HTMLDelAttributes;
	details: HTMLDetailsAttributes;
	dfn: HTMLAttributes<HTMLElement>;
	dialog: HTMLDialogAttributes;
	div: HTMLAttributes<HTMLDivElement>;
	dl: HTMLAttributes<HTMLDListElement>;
	dt: HTMLAttributes<HTMLElement>;
	em: HTMLAttributes<HTMLElement>;
	embed: HTMLEmbedAttributes;
	fieldset: HTMLFieldsetAttributes;
	figcaption: HTMLAttributes<HTMLElement>;
	figure: HTMLAttributes<HTMLElement>;
	footer: HTMLAttributes<HTMLElement>;
	form: HTMLFormAttributes;
	h1: HTMLAttributes<HTMLHeadingElement>;
	h2: HTMLAttributes<HTMLHeadingElement>;
	h3: HTMLAttributes<HTMLHeadingElement>;
	h4: HTMLAttributes<HTMLHeadingElement>;
	h5: HTMLAttributes<HTMLHeadingElement>;
	h6: HTMLAttributes<HTMLHeadingElement>;
	head: HTMLAttributes<HTMLElement>;
	header: HTMLAttributes<HTMLElement>;
	hgroup: HTMLAttributes<HTMLElement>;
	hr: HTMLAttributes<HTMLHRElement>;
	html: HTMLHtmlAttributes;
	i: HTMLAttributes<HTMLElement>;
	iframe: HTMLIframeAttributes;
	img: HTMLImgAttributes;
	input: HTMLInputAttributes;
	ins: HTMLInsAttributes;
	kbd: HTMLAttributes<HTMLElement>;
	keygen: HTMLKeygenAttributes;
	label: HTMLLabelAttributes;
	legend: HTMLAttributes<HTMLLegendElement>;
	li: HTMLLiAttributes;
	link: HTMLLinkAttributes;
	main: HTMLAttributes<HTMLElement>;
	map: HTMLMapAttributes;
	mark: HTMLAttributes<HTMLElement>;
	menu: HTMLMenuAttributes;
	menuitem: HTMLAttributes<HTMLElement>;
	meta: HTMLMetaAttributes;
	meter: HTMLMeterAttributes;
	nav: HTMLAttributes<HTMLElement>;
	noscript: HTMLAttributes<HTMLElement>;
	object: HTMLObjectAttributes;
	ol: HTMLOlAttributes;
	optgroup: HTMLOptgroupAttributes;
	option: HTMLOptionAttributes;
	output: HTMLOutputAttributes;
	p: HTMLAttributes<HTMLParagraphElement>;
	param: HTMLParamAttributes;
	picture: HTMLAttributes<HTMLElement>;
	pre: HTMLAttributes<HTMLPreElement>;
	progress: HTMLProgressAttributes;
	q: HTMLQuoteAttributes;
	rp: HTMLAttributes<HTMLElement>;
	rt: HTMLAttributes<HTMLElement>;
	ruby: HTMLAttributes<HTMLElement>;
	s: HTMLAttributes<HTMLElement>;
	samp: HTMLAttributes<HTMLElement>;
	slot: HTMLSlotAttributes;
	script: HTMLScriptAttributes;
	search: HTMLAttributes<HTMLElement>;
	section: HTMLAttributes<HTMLElement>;
	select: HTMLSelectAttributes;
	small: HTMLAttributes<HTMLElement>;
	source: HTMLSourceAttributes;
	span: HTMLAttributes<HTMLSpanElement>;
	strong: HTMLAttributes<HTMLElement>;
	style: HTMLStyleAttributes;
	sub: HTMLAttributes<HTMLElement>;
	summary: HTMLAttributes<HTMLElement>;
	sup: HTMLAttributes<HTMLElement>;
	table: HTMLTableAttributes;
	template: HTMLTemplateAttributes;
	tbody: HTMLAttributes<HTMLTableSectionElement>;
	td: HTMLTdAttributes;
	textarea: HTMLTextareaAttributes;
	tfoot: HTMLAttributes<HTMLTableSectionElement>;
	th: HTMLThAttributes;
	thead: HTMLAttributes<HTMLTableSectionElement>;
	time: HTMLTimeAttributes;
	title: HTMLAttributes<HTMLTitleElement>;
	tr: HTMLAttributes<HTMLTableRowElement>;
	track: HTMLTrackAttributes;
	u: HTMLAttributes<HTMLElement>;
	ul: HTMLAttributes<HTMLUListElement>;
	var: HTMLAttributes<HTMLElement>;
	video: HTMLVideoAttributes;
	wbr: HTMLAttributes<HTMLElement>;
	webview: HTMLWebViewAttributes;
	// SVG
	svg: SVGAttributes<SVGSVGElement>;
	animate: SVGAttributes<SVGAnimateElement>;
	animateMotion: SVGAttributes<SVGElement>;
	animateTransform: SVGAttributes<SVGAnimateTransformElement>;
	circle: SVGAttributes<SVGCircleElement>;
	clipPath: SVGAttributes<SVGClipPathElement>;
	defs: SVGAttributes<SVGDefsElement>;
	desc: SVGAttributes<SVGDescElement>;
	ellipse: SVGAttributes<SVGEllipseElement>;
	feBlend: SVGAttributes<SVGFEBlendElement>;
	feColorMatrix: SVGAttributes<SVGFEColorMatrixElement>;
	feComponentTransfer: SVGAttributes<SVGFEComponentTransferElement>;
	feComposite: SVGAttributes<SVGFECompositeElement>;
	feConvolveMatrix: SVGAttributes<SVGFEConvolveMatrixElement>;
	feDiffuseLighting: SVGAttributes<SVGFEDiffuseLightingElement>;
	feDisplacementMap: SVGAttributes<SVGFEDisplacementMapElement>;
	feDistantLight: SVGAttributes<SVGFEDistantLightElement>;
	feDropShadow: SVGAttributes<SVGFEDropShadowElement>;
	feFlood: SVGAttributes<SVGFEFloodElement>;
	feFuncA: SVGAttributes<SVGFEFuncAElement>;
	feFuncB: SVGAttributes<SVGFEFuncBElement>;
	feFuncG: SVGAttributes<SVGFEFuncGElement>;
	feFuncR: SVGAttributes<SVGFEFuncRElement>;
	feGaussianBlur: SVGAttributes<SVGFEGaussianBlurElement>;
	feImage: SVGAttributes<SVGFEImageElement>;
	feMerge: SVGAttributes<SVGFEMergeElement>;
	feMergeNode: SVGAttributes<SVGFEMergeNodeElement>;
	feMorphology: SVGAttributes<SVGFEMorphologyElement>;
	feOffset: SVGAttributes<SVGFEOffsetElement>;
	fePointLight: SVGAttributes<SVGFEPointLightElement>;
	feSpecularLighting: SVGAttributes<SVGFESpecularLightingElement>;
	feSpotLight: SVGAttributes<SVGFESpotLightElement>;
	feTile: SVGAttributes<SVGFETileElement>;
	feTurbulence: SVGAttributes<SVGFETurbulenceElement>;
	filter: SVGAttributes<SVGFilterElement>;
	foreignObject: SVGAttributes<SVGForeignObjectElement>;
	g: SVGAttributes<SVGGElement>;
	image: SVGAttributes<SVGImageElement>;
	line: SVGAttributes<SVGLineElement>;
	linearGradient: SVGAttributes<SVGLinearGradientElement>;
	marker: SVGAttributes<SVGMarkerElement>;
	mask: SVGAttributes<SVGMaskElement>;
	metadata: SVGAttributes<SVGMetadataElement>;
	mpath: SVGAttributes<SVGElement>;
	path: SVGAttributes<SVGPathElement>;
	pattern: SVGAttributes<SVGPatternElement>;
	polygon: SVGAttributes<SVGPolygonElement>;
	polyline: SVGAttributes<SVGPolylineElement>;
	radialGradient: SVGAttributes<SVGRadialGradientElement>;
	rect: SVGAttributes<SVGRectElement>;
	stop: SVGAttributes<SVGStopElement>;
	switch: SVGAttributes<SVGSwitchElement>;
	symbol: SVGAttributes<SVGSymbolElement>;
	text: SVGAttributes<SVGTextElement>;
	textPath: SVGAttributes<SVGTextPathElement>;
	tspan: SVGAttributes<SVGTSpanElement>;
	use: SVGAttributes<SVGUseElement>;
	view: SVGAttributes<SVGViewElement>;
	// Svelte specific
	"svelte:window": SvelteWindowAttributes;
	"svelte:document": SvelteDocumentAttributes;
	"svelte:body": HTMLAttributes<HTMLElement>;
	"svelte:fragment": {
		slot?: string;
	};
	"svelte:options": {
		customElement?: string | undefined | {
			tag?: string;
			shadow?: "open" | "none" | ShadowRootInit | undefined;
			props?: Record<string, {
				attribute?: string;
				reflect?: boolean;
				type?: "String" | "Boolean" | "Number" | "Array" | "Object";
			}> | undefined;
			extend?: (svelteCustomElementClass: new () => HTMLElement) => new () => HTMLElement | undefined;
		};
		immutable?: boolean | undefined;
		accessors?: boolean | undefined;
		namespace?: string | undefined;
		[name: string]: any;
	};
	"svelte:head": {
		[name: string]: any;
	};
	"svelte:boundary": {
		onerror?: (error: unknown, reset: () => void) => void;
		failed?: Snippet<[
			error: unknown,
			reset: () => void
		]>;
		pending?: Snippet;
	};
	[name: string]: {
		[name: string]: any;
	};
}
export type ClassValue = string | import("clsx").ClassArray | import("clsx").ClassDictionary;
type Primitive$1 = null | undefined | string | number | boolean | symbol | bigint;
/**
Extract all optional keys from the given type.

This is useful when you want to create a new type that contains different type values for the optional keys only.

@example
```
import type {OptionalKeysOf, Except} from 'type-fest';

interface User {
	name: string;
	surname: string;

	luckyNumber?: number;
}

const REMOVE_FIELD = Symbol('remove field symbol');
type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
};

const update1: UpdateOperation<User> = {
	name: 'Alice'
};

const update2: UpdateOperation<User> = {
	name: 'Bob',
	luckyNumber: REMOVE_FIELD
};
```

@category Utilities
*/
export type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
 ? (keyof {
	[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never;
}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
 : never; // Should never happen
/**
Extract all required keys from the given type.

This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...

@example
```
import type {RequiredKeysOf} from 'type-fest';

declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;

interface User {
	name: string;
	surname: string;

	luckyNumber?: number;
}

const validator1 = createValidation<User>('name', value => value.length < 25);
const validator2 = createValidation<User>('surname', value => value.length < 25);
```

@category Utilities
*/
export type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
 ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never; // Should never happen
/**
Returns a boolean for whether the given type is `never`.

@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
@link https://stackoverflow.com/a/53984913/10292952
@link https://www.zhenghao.io/posts/ts-never

Useful in type utilities, such as checking if something does not occur.

@example
```
import type {IsNever, And} from 'type-fest';

// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
type AreStringsEqual<A extends string, B extends string> =
	And<
		IsNever<Exclude<A, B>> extends true ? true : false,
		IsNever<Exclude<B, A>> extends true ? true : false
	>;

type EndIfEqual<I extends string, O extends string> =
	AreStringsEqual<I, O> extends true
		? never
		: void;

function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
	if (input === output) {
		process.exit(0);
	}
}

endIfEqual('abc', 'abc');
//=> never

endIfEqual('abc', '123');
//=> void
```

@category Type Guard
@category Utilities
*/
export type IsNever<T> = [
	T
] extends [
	never
] ? true : false;
/**
An if-else-like type that resolves depending on whether the given type is `never`.

@see {@link IsNever}

@example
```
import type {IfNever} from 'type-fest';

type ShouldBeTrue = IfNever<never>;
//=> true

type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
//=> 'bar'
```

@category Type Guard
@category Utilities
*/
export type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
type NoInfer$1<T> = T extends infer U ? U : never;
type IsAny$1<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
/**
Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.

@example
```
import type {Simplify} from 'type-fest';

type PositionProps = {
	top: number;
	left: number;
};

type SizeProps = {
	width: number;
	height: number;
};

// In your editor, hovering over `Props` will show a flattened object with all the properties.
type Props = Simplify<PositionProps & SizeProps>;
```

Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.

If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.

@example
```
import type {Simplify} from 'type-fest';

interface SomeInterface {
	foo: number;
	bar?: string;
	baz: number | undefined;
}

type SomeType = {
	foo: number;
	bar?: string;
	baz: number | undefined;
};

const literal = {foo: 123, bar: 'hello', baz: 456};
const someType: SomeType = literal;
const someInterface: SomeInterface = literal;

function fn(object: Record<string, unknown>): void {}

fn(literal); // Good: literal object type is sealed
fn(someType); // Good: type is sealed
fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
```

@link https://github.com/microsoft/TypeScript/issues/15300
@see SimplifyDeep
@category Object
*/
export type Simplify<T> = {
	[KeyType in keyof T]: T[KeyType];
} & {};
type OmitIndexSignature$1<ObjectType> = {
	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
};
/**
Pick only index signatures from the given object type, leaving out all explicitly defined properties.

This is the counterpart of `OmitIndexSignature`.

@example
```
import type {PickIndexSignature} from 'type-fest';

declare const symbolKey: unique symbol;

type Example = {
	// These index signatures will remain.
	[x: string]: unknown;
	[x: number]: unknown;
	[x: symbol]: unknown;
	[x: `head-${string}`]: string;
	[x: `${string}-tail`]: string;
	[x: `head-${string}-tail`]: string;
	[x: `${bigint}`]: string;
	[x: `embedded-${number}`]: string;

	// These explicitly defined keys will be removed.
	['kebab-case-key']: string;
	[symbolKey]: string;
	foo: 'bar';
	qux?: 'baz';
};

type ExampleIndexSignature = PickIndexSignature<Example>;
// {
// 	[x: string]: unknown;
// 	[x: number]: unknown;
// 	[x: symbol]: unknown;
// 	[x: `head-${string}`]: string;
// 	[x: `${string}-tail`]: string;
// 	[x: `head-${string}-tail`]: string;
// 	[x: `${bigint}`]: string;
// 	[x: `embedded-${number}`]: string;
// }
```

@see OmitIndexSignature
@category Object
*/
export type PickIndexSignature<ObjectType> = {
	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
};
// Merges two objects without worrying about index signatures.
export type SimpleMerge<Destination, Source> = {
	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
} & Source;
/**
Merge two types into a new type. Keys of the second type overrides keys of the first type.

@example
```
import type {Merge} from 'type-fest';

interface Foo {
	[x: string]: unknown;
	[x: number]: unknown;
	foo: string;
	bar: symbol;
}

type Bar = {
	[x: number]: number;
	[x: symbol]: unknown;
	bar: Date;
	baz: boolean;
};

export type FooBar = Merge<Foo, Bar>;
// => {
// 	[x: string]: unknown;
// 	[x: number]: number;
// 	[x: symbol]: unknown;
// 	foo: string;
// 	bar: Date;
// 	baz: boolean;
// }
```

@category Object
*/
export type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature$1<Destination>, OmitIndexSignature$1<Source>>>;
/**
An if-else-like type that resolves depending on whether the given type is `any`.

@see {@link IsAny}

@example
```
import type {IfAny} from 'type-fest';

type ShouldBeTrue = IfAny<any>;
//=> true

type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
//=> 'bar'
```

@category Type Guard
@category Utilities
*/
export type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny$1<T> extends true ? TypeIfAny : TypeIfNotAny);
/**
Matches any primitive, `void`, `Date`, or `RegExp` value.
*/
export type BuiltIns = Primitive$1 | void | Date | RegExp;
/**
Matches non-recursive types.
*/
export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
/**
Merges user specified options with default options.

@example
```
type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
type SpecifiedOptions = {leavesOnly: true};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//=> {maxRecursionDepth: 10; leavesOnly: true}
```

@example
```
// Complains if default values are not provided for optional options

type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10};
type SpecifiedOptions = {};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//                                              ~~~~~~~~~~~~~~~~~~~
// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
```

@example
```
// Complains if an option's default type does not conform to the expected type

type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
type SpecifiedOptions = {};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//                                              ~~~~~~~~~~~~~~~~~~~
// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
```

@example
```
// Complains if an option's specified type does not conform to the expected type

type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
type SpecifiedOptions = {leavesOnly: 'yes'};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//                                                                   ~~~~~~~~~~~~~~~~
// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
```
*/
export type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny<SpecifiedOptions, Defaults, IfNever<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, {
	[Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key];
}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
>>;
/**
Recursively simplifies a type while including and/or excluding certain types from being simplified.

This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.

See {@link ConditionalSimplify} for usages and examples.

@internal
@experimental
@category Object
*/
export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType ? Type : Type extends IncludeType ? {
	[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>;
} : Type;
/**
Deeply simplifies an object type.

You can exclude certain types from being simplified by providing them in the second generic `ExcludeType`.

Useful to flatten the type output to improve type hints shown in editors.

@example
```
import type {SimplifyDeep} from 'type-fest';

type PositionX = {
	left: number;
	right: number;
};

type PositionY = {
	top: number;
	bottom: number;
};

type Properties1 = {
	height: number;
	position: PositionY;
};

type Properties2 = {
	width: number;
	position: PositionX;
};

type Properties = Properties1 & Properties2;
// In your editor, hovering over `Props` will show the following:
//
// type Properties = Properties1 & Properties2;

type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2>;
// But if wrapped in SimplifyDeep, hovering over `SimplifyDeepProperties` will show a flattened object with all the properties:
//
// SimplifyDeepProperties = {
// 	height: number;
// 	width: number;
// 	position: {
// 		top: number;
// 		bottom: number;
// 		left: number;
// 		right: number;
// 	};
// };
```

@example
```
import type {SimplifyDeep} from 'type-fest';

// A complex type that you don't want or need to simplify
type ComplexType = {
	a: string;
	b: 'b';
	c: number;
	...
};

type PositionX = {
	left: number;
	right: number;
};

type PositionY = {
	top: number;
	bottom: number;
};

// You want to simplify all other types
type Properties1 = {
	height: number;
	position: PositionY;
	foo: ComplexType;
};

type Properties2 = {
	width: number;
	position: PositionX;
	foo: ComplexType;
};

type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexType>;
// If wrapped in `SimplifyDeep` and set `ComplexType` to exclude, hovering over `SimplifyDeepProperties` will
// show a flattened object with all the properties except `ComplexType`:
//
// SimplifyDeepProperties = {
// 	height: number;
// 	width: number;
// 	position: {
// 		top: number;
// 		bottom: number;
// 		left: number;
// 		right: number;
// 	};
//	foo: ComplexType;
// };
```

@see Simplify
@category Object
*/
export type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>, object>;
/**
@see {@link PartialDeep}
*/
export type PartialDeepOptions = {
	/**
	Whether to affect the individual elements of arrays and tuples.

	@default false
	*/
	readonly recurseIntoArrays?: boolean;
	/**
	Allows `undefined` values in non-tuple arrays.

	- When set to `true`, elements of non-tuple arrays can be `undefined`.
	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.

	@default true

	@example
	You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:

	```
	import type {PartialDeep} from 'type-fest';

	type Settings = {
		languages: string[];
	};

	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;

	partialSettings.languages = [undefined]; // Error
	partialSettings.languages = []; // Ok
	```
	*/
	readonly allowUndefinedInNonTupleArrays?: boolean;
};
export type DefaultPartialDeepOptions = {
	recurseIntoArrays: false;
	allowUndefinedInNonTupleArrays: true;
};
/**
Create a type from another type with all keys and nested keys set to optional.

Use-cases:
- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.

@example
```
import type {PartialDeep} from 'type-fest';

const settings: Settings = {
	textEditor: {
		fontSize: 14,
		fontColor: '#000000',
		fontWeight: 400
	},
	autocomplete: false,
	autosave: true
};

const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
	return {...settings, ...savedSettings};
}

settings = applySavedSettings({textEditor: {fontWeight: 500}});
```

By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:

```
import type {PartialDeep} from 'type-fest';

type Settings = {
	languages: string[];
}

const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
	languages: [undefined]
};
```

@see {@link PartialDeepOptions}

@category Object
@category Array
@category Set
@category Map
*/
export type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
export type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : IsNever<keyof T> extends true // For functions with no properties
 ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 ? Options["recurseIntoArrays"] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
 ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
 ? ReadonlyArray<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
 : T // If they don't opt into array testing, just use the original type
 : PartialObjectDeep<T, Options> : unknown;
/**
Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
*/
export type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
/**
Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
*/
export type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
/**
Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
*/
export type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
/**
Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
*/
export type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
/**
Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
*/
export type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = (ObjectType extends (...arguments_: any) => unknown ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({
	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>;
});
export type RemovePrefix<Prefix extends string, Value> = Value extends `${Prefix}${infer Rest}` ? Rest : Value;
export type OnlyOnKeys<Keys> = Keys extends `on${string}` ? (Keys extends `on:${string}` ? never : Keys) : never;
export type HtmlListenersFor<Obj> = {
	[Key in OnlyOnKeys<keyof Obj> as RemovePrefix<"on", Key>]: Obj[Key];
};
export type EventListenersFor<Element extends keyof HTMLElementTagNameMap> = HtmlListenersFor<SvelteHTMLElements[Element]> & {
	init?: (node: HTMLElementTagNameMap[Element]) => void;
	destroy?: (node: HTMLElementTagNameMap[Element]) => void;
};
export type LiipgptListenersRaw = {
	error: (error: keyof ErrorTranslation) => void;
	conversation: (state: ConversationState) => void;
	route: (route: Route) => void;
	elements: {
		avatar: Simplify<EventListenersFor<"div">>;
		avatarLarge: Simplify<EventListenersFor<"div">>;
		chatInput: Simplify<EventListenersFor<"textarea">>;
		predefinedQuestion: Simplify<EventListenersFor<"button">>;
	};
};
export type LiipgptListeners = PartialDeep<LiipgptListenersRaw>;
export declare const chatConfigSchema: z.ZodObject<{
	showPredefinedQuestions: z.ZodOptional<z.ZodBoolean>;
	showOverallFeedbackButton: z.ZodOptional<z.ZodBoolean>;
	showOverallFeedbackEmail: z.ZodOptional<z.ZodBoolean>;
	showCloseChatButton: z.ZodOptional<z.ZodBoolean>;
	showContextMenu: z.ZodOptional<z.ZodBoolean>;
	showContextInfo: z.ZodOptional<z.ZodBoolean>;
	showReferencesByDefault: z.ZodOptional<z.ZodBoolean>;
	showExpandedSelectors: z.ZodOptional<z.ZodBoolean>;
	showTextFeedback: z.ZodOptional<z.ZodBoolean>;
	inlineLayout: z.ZodOptional<z.ZodBoolean>;
	allowAudioInput: z.ZodOptional<z.ZodBoolean>;
	blockPII: z.ZodOptional<z.ZodBoolean>;
	questionPrefix: z.ZodOptional<z.ZodString>;
	menu: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
		en: "en";
		de: "de";
		fr: "fr";
		it: "it";
	}> & z.core.$partial, z.ZodArray<z.ZodObject<{
		label: z.ZodString;
		icon: z.ZodString;
		url: z.ZodString;
		target: z.ZodOptional<z.ZodEnum<{
			_blank: "_blank";
			_self: "_self";
		}>>;
	}, z.core.$strip>>>>>;
	supportedLanguages: z.ZodOptional<z.ZodArray<z.ZodEnum<{
		en: "en";
		de: "de";
		fr: "fr";
		it: "it";
	}>>>;
	classification: z.ZodOptional<z.ZodOptional<z.ZodObject<{
		impact: z.ZodOptional<z.ZodObject<{
			label: z.ZodString;
			options: z.ZodArray<z.ZodObject<{
				label: z.ZodString;
				value: z.ZodNumber;
			}, z.core.$strip>>;
		}, z.core.$strip>>;
		quality: z.ZodOptional<z.ZodObject<{
			label: z.ZodString;
			options: z.ZodArray<z.ZodObject<{
				label: z.ZodString;
				value: z.ZodNumber;
			}, z.core.$strip>>;
		}, z.core.$strip>>;
	}, z.core.$strip>>>;
	theme: z.ZodOptional<z.ZodObject<{
		avatarImageUrl: z.ZodOptional<z.ZodString>;
		colors: z.ZodOptional<z.ZodObject<{
			brand: z.ZodOptional<z.ZodUnion<readonly [
				z.ZodObject<{
					"50": z.ZodString;
					"100": z.ZodString;
					"200": z.ZodString;
					"300": z.ZodString;
					"400": z.ZodString;
					"500": z.ZodString;
					"600": z.ZodString;
					"700": z.ZodString;
					"800": z.ZodString;
					"900": z.ZodString;
					"950": z.ZodString;
				}, z.core.$strip>,
				z.ZodEnum<{
					slate: "slate";
					gray: "gray";
					zinc: "zinc";
					neutral: "neutral";
					stone: "stone";
					red: "red";
					orange: "orange";
					amber: "amber";
					yellow: "yellow";
					lime: "lime";
					green: "green";
					emerald: "emerald";
					teal: "teal";
					cyan: "cyan";
					sky: "sky";
					blue: "blue";
					indigo: "indigo";
					violet: "violet";
					purple: "purple";
					fuchsia: "fuchsia";
					pink: "pink";
					rose: "rose";
				}>
			]>>;
			highlight: z.ZodOptional<z.ZodUnion<readonly [
				z.ZodObject<{
					"50": z.ZodString;
					"100": z.ZodString;
					"200": z.ZodString;
					"300": z.ZodString;
					"400": z.ZodString;
					"500": z.ZodString;
					"600": z.ZodString;
					"700": z.ZodString;
					"800": z.ZodString;
					"900": z.ZodString;
					"950": z.ZodString;
				}, z.core.$strip>,
				z.ZodEnum<{
					slate: "slate";
					gray: "gray";
					zinc: "zinc";
					neutral: "neutral";
					stone: "stone";
					red: "red";
					orange: "orange";
					amber: "amber";
					yellow: "yellow";
					lime: "lime";
					green: "green";
					emerald: "emerald";
					teal: "teal";
					cyan: "cyan";
					sky: "sky";
					blue: "blue";
					indigo: "indigo";
					violet: "violet";
					purple: "purple";
					fuchsia: "fuchsia";
					pink: "pink";
					rose: "rose";
				}>
			]>>;
			grey: z.ZodOptional<z.ZodUnion<readonly [
				z.ZodIntersection<z.ZodObject<{
					"50": z.ZodString;
					"100": z.ZodString;
					"200": z.ZodString;
					"300": z.ZodString;
					"400": z.ZodString;
					"500": z.ZodString;
					"600": z.ZodString;
					"700": z.ZodString;
					"800": z.ZodString;
					"900": z.ZodString;
					"950": z.ZodString;
				}, z.core.$strip>, z.ZodObject<{
					"0": z.ZodString;
					"1000": z.ZodString;
				}, z.core.$strip>>,
				z.ZodEnum<{
					slate: "slate";
					gray: "gray";
					zinc: "zinc";
					neutral: "neutral";
					stone: "stone";
					red: "red";
					orange: "orange";
					amber: "amber";
					yellow: "yellow";
					lime: "lime";
					green: "green";
					emerald: "emerald";
					teal: "teal";
					cyan: "cyan";
					sky: "sky";
					blue: "blue";
					indigo: "indigo";
					violet: "violet";
					purple: "purple";
					fuchsia: "fuchsia";
					pink: "pink";
					rose: "rose";
				}>
			]>>;
			background: z.ZodOptional<z.ZodString>;
			text: z.ZodOptional<z.ZodString>;
			anchor: z.ZodOptional<z.ZodObject<{
				default: z.ZodOptional<z.ZodString>;
				hover: z.ZodOptional<z.ZodString>;
			}, z.core.$strip>>;
		}, z.core.$strip>>;
		font: z.ZodOptional<z.ZodObject<{
			family: z.ZodOptional<z.ZodString>;
			urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
			sizeXs: z.ZodOptional<z.ZodUnion<[
				z.ZodObject<{
					minRem: z.ZodNumber;
					maxRem: z.ZodNumber;
				}, z.core.$strip>,
				z.ZodString
			]>>;
			sizeSm: z.ZodOptional<z.ZodUnion<[
				z.ZodObject<{
					minRem: z.ZodNumber;
					maxRem: z.ZodNumber;
				}, z.core.$strip>,
				z.ZodString
			]>>;
			sizeBody: z.ZodOptional<z.ZodUnion<[
				z.ZodObject<{
					minRem: z.ZodNumber;
					maxRem: z.ZodNumber;
				}, z.core.$strip>,
				z.ZodString
			]>>;
			sizeH3: z.ZodOptional<z.ZodUnion<[
				z.ZodObject<{
					minRem: z.ZodNumber;
					maxRem: z.ZodNumber;
				}, z.core.$strip>,
				z.ZodString
			]>>;
			sizeH2: z.ZodOptional<z.ZodUnion<[
				z.ZodObject<{
					minRem: z.ZodNumber;
					maxRem: z.ZodNumber;
				}, z.core.$strip>,
				z.ZodString
			]>>;
			sizeH1: z.ZodOptional<z.ZodUnion<[
				z.ZodObject<{
					minRem: z.ZodNumber;
					maxRem: z.ZodNumber;
				}, z.core.$strip>,
				z.ZodString
			]>>;
			weightNormal: z.ZodOptional<z.ZodString>;
			weightBold: z.ZodOptional<z.ZodString>;
			weightTitle: z.ZodOptional<z.ZodString>;
		}, z.core.$strip>>;
		borderRadius: z.ZodOptional<z.ZodUnion<[
			z.ZodObject<{
				minRem: z.ZodNumber;
				maxRem: z.ZodNumber;
			}, z.core.$strip>,
			z.ZodString
		]>>;
		fineGrained: z.ZodOptional<z.ZodObject<{
			light: z.ZodOptional<z.ZodObject<{
				customCSS: z.ZodOptional<z.ZodString>;
				fontCSS: z.ZodOptional<z.ZodString>;
				fontURLs: z.ZodOptional<z.ZodArray<z.ZodString>>;
				tokens: z.ZodOptional<z.ZodObject<{
					font: z.ZodOptional<z.ZodObject<{
						family: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
					colors: z.ZodOptional<z.ZodObject<{
						brand: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
						accent: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
						highlight: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
						grey: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
					}, z.core.$strip>>;
					base: z.ZodOptional<z.ZodObject<{
						fontSizeXs: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeSm: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeBody: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeH3: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeH2: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeH1: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontWeightNormal: z.ZodOptional<z.ZodString>;
						fontWeightBold: z.ZodOptional<z.ZodString>;
						fontWeightTitle: z.ZodOptional<z.ZodString>;
						lineHeightDefault: z.ZodOptional<z.ZodString>;
						lineHeightSnug: z.ZodOptional<z.ZodString>;
						lineHeightTight: z.ZodOptional<z.ZodString>;
						borderRadius: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						lineColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
					components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodObject<{
						borderRadius: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
							z.ZodString,
							z.ZodNumber
						]>>>;
						hover: z.ZodOptional<z.ZodObject<{
							color: z.ZodOptional<z.ZodString>;
							background: z.ZodOptional<z.ZodString>;
							borderWidth: z.ZodOptional<z.ZodString>;
							borderColor: z.ZodOptional<z.ZodString>;
							boxShadow: z.ZodOptional<z.ZodString>;
						}, z.core.$strip>>;
						focus: z.ZodOptional<z.ZodObject<{
							color: z.ZodOptional<z.ZodString>;
							background: z.ZodOptional<z.ZodString>;
							borderWidth: z.ZodOptional<z.ZodString>;
							borderColor: z.ZodOptional<z.ZodString>;
							boxShadow: z.ZodOptional<z.ZodString>;
						}, z.core.$strip>>;
					}, z.core.$strip>, z.ZodObject<{
						color: z.ZodOptional<z.ZodString>;
						background: z.ZodOptional<z.ZodString>;
						borderWidth: z.ZodOptional<z.ZodString>;
						borderColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>>>;
					svgs: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
						record: "record";
						abort: "abort";
						message: "message";
						lightMode: "lightMode";
						darkMode: "darkMode";
						audio: "audio";
						menu: "menu";
						copy: "copy";
						submit: "submit";
						predefinedQuestion: "predefinedQuestion";
						edit: "edit";
						newConversation: "newConversation";
						voteUp: "voteUp";
						voteDown: "voteDown";
						retry: "retry";
						messageLoading: "messageLoading";
						thread: "thread";
						expand: "expand";
						help: "help";
						attach: "attach";
						reward: "reward";
						share: "share";
						dismiss: "dismiss";
						info: "info";
						menuClose: "menuClose";
						chevronDown: "chevronDown";
						chevronUp: "chevronUp";
						chevronTopDown: "chevronTopDown";
						chevronDownSmall: "chevronDownSmall";
						internalLink: "internalLink";
						externalLink: "externalLink";
						liip: "liip";
						avatar: "avatar";
						avatarLarge: "avatarLarge";
						openChat: "openChat";
						speechInput: "speechInput";
						listUnordered: "listUnordered";
						settings: "settings";
						settingsClose: "settingsClose";
						sources: "sources";
						model: "model";
						checkbox: "checkbox";
						warning: "warning";
						headerLogo: "headerLogo";
						embedAvatar: "embedAvatar";
					}> & z.core.$partial, z.ZodString>>;
				}, z.core.$strip>>;
			}, z.core.$strip>>;
			dark: z.ZodOptional<z.ZodObject<{
				customCSS: z.ZodOptional<z.ZodString>;
				fontCSS: z.ZodOptional<z.ZodString>;
				fontURLs: z.ZodOptional<z.ZodArray<z.ZodString>>;
				tokens: z.ZodOptional<z.ZodObject<{
					font: z.ZodOptional<z.ZodObject<{
						family: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
					colors: z.ZodOptional<z.ZodObject<{
						brand: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
						accent: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
						highlight: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
						grey: z.ZodOptional<z.ZodObject<{
							0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
							50: z.ZodOptional<z.ZodString>;
							100: z.ZodOptional<z.ZodString>;
							200: z.ZodOptional<z.ZodString>;
							300: z.ZodOptional<z.ZodString>;
							400: z.ZodOptional<z.ZodString>;
							500: z.ZodOptional<z.ZodString>;
							600: z.ZodOptional<z.ZodString>;
							700: z.ZodOptional<z.ZodString>;
							800: z.ZodOptional<z.ZodString>;
							900: z.ZodOptional<z.ZodString>;
							950: z.ZodOptional<z.ZodString>;
							1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						}, z.core.$strip>>;
					}, z.core.$strip>>;
					base: z.ZodOptional<z.ZodObject<{
						fontSizeXs: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeSm: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeBody: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeH3: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeH2: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontSizeH1: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						fontWeightNormal: z.ZodOptional<z.ZodString>;
						fontWeightBold: z.ZodOptional<z.ZodString>;
						fontWeightTitle: z.ZodOptional<z.ZodString>;
						lineHeightDefault: z.ZodOptional<z.ZodString>;
						lineHeightSnug: z.ZodOptional<z.ZodString>;
						lineHeightTight: z.ZodOptional<z.ZodString>;
						borderRadius: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						lineColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
					components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodObject<{
						borderRadius: z.ZodOptional<z.ZodUnion<[
							z.ZodObject<{
								minRem: z.ZodNumber;
								maxRem: z.ZodNumber;
							}, z.core.$strip>,
							z.ZodString
						]>>;
						custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
							z.ZodString,
							z.ZodNumber
						]>>>;
						hover: z.ZodOptional<z.ZodObject<{
							color: z.ZodOptional<z.ZodString>;
							background: z.ZodOptional<z.ZodString>;
							borderWidth: z.ZodOptional<z.ZodString>;
							borderColor: z.ZodOptional<z.ZodString>;
							boxShadow: z.ZodOptional<z.ZodString>;
						}, z.core.$strip>>;
						focus: z.ZodOptional<z.ZodObject<{
							color: z.ZodOptional<z.ZodString>;
							background: z.ZodOptional<z.ZodString>;
							borderWidth: z.ZodOptional<z.ZodString>;
							borderColor: z.ZodOptional<z.ZodString>;
							boxShadow: z.ZodOptional<z.ZodString>;
						}, z.core.$strip>>;
					}, z.core.$strip>, z.ZodObject<{
						color: z.ZodOptional<z.ZodString>;
						background: z.ZodOptional<z.ZodString>;
						borderWidth: z.ZodOptional<z.ZodString>;
						borderColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>>>;
					svgs: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
						record: "record";
						abort: "abort";
						message: "message";
						lightMode: "lightMode";
						darkMode: "darkMode";
						audio: "audio";
						menu: "menu";
						copy: "copy";
						submit: "submit";
						predefinedQuestion: "predefinedQuestion";
						edit: "edit";
						newConversation: "newConversation";
						voteUp: "voteUp";
						voteDown: "voteDown";
						retry: "retry";
						messageLoading: "messageLoading";
						thread: "thread";
						expand: "expand";
						help: "help";
						attach: "attach";
						reward: "reward";
						share: "share";
						dismiss: "dismiss";
						info: "info";
						menuClose: "menuClose";
						chevronDown: "chevronDown";
						chevronUp: "chevronUp";
						chevronTopDown: "chevronTopDown";
						chevronDownSmall: "chevronDownSmall";
						internalLink: "internalLink";
						externalLink: "externalLink";
						liip: "liip";
						avatar: "avatar";
						avatarLarge: "avatarLarge";
						openChat: "openChat";
						speechInput: "speechInput";
						listUnordered: "listUnordered";
						settings: "settings";
						settingsClose: "settingsClose";
						sources: "sources";
						model: "model";
						checkbox: "checkbox";
						warning: "warning";
						headerLogo: "headerLogo";
						embedAvatar: "embedAvatar";
					}> & z.core.$partial, z.ZodString>>;
				}, z.core.$strip>>;
			}, z.core.$strip>>;
		}, z.core.$strip>>;
	}, z.core.$strip>>;
	translations: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
		en: "en";
		de: "de";
		fr: "fr";
		it: "it";
	}> & z.core.$partial, z.ZodObject<{
		introductionTitle: z.ZodOptional<z.ZodString>;
		introductionDisclaimer: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		termsInvitationToConsent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		chatInputPlaceholder: z.ZodOptional<z.ZodString>;
		chatInputPlaceholderListening: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		chatInputSubmit: z.ZodOptional<z.ZodString>;
		chatInputAbort: z.ZodOptional<z.ZodString>;
		chatInputStartListening: z.ZodOptional<z.ZodString>;
		chatInputStopListening: z.ZodOptional<z.ZodString>;
		referenceLink: z.ZodOptional<z.ZodString>;
		referencesDisplay: z.ZodOptional<z.ZodString>;
		referencesHide: z.ZodOptional<z.ZodString>;
		referencesTitle: z.ZodOptional<z.ZodString>;
		referencesFurtherTitle: z.ZodOptional<z.ZodString>;
		newChat: z.ZodOptional<z.ZodString>;
		maintenanceModeError: z.ZodOptional<z.ZodString>;
		messageBotLoading: z.ZodOptional<z.ZodString>;
		messageBotError: z.ZodOptional<z.ZodString>;
		messageBotDefaultError: z.ZodOptional<z.ZodString>;
		noResultsFound: z.ZodOptional<z.ZodString>;
		chatFooterText: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		scrollToBottom: z.ZodOptional<z.ZodString>;
		openButtonTitle: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		openButtonDescription: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		openMenu: z.ZodOptional<z.ZodString>;
		openInfo: z.ZodOptional<z.ZodString>;
		aboutThisChat: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		closeMenu: z.ZodOptional<z.ZodString>;
		closeChat: z.ZodOptional<z.ZodString>;
		close: z.ZodOptional<z.ZodString>;
		send: z.ZodOptional<z.ZodString>;
		thankYouForFeedback: z.ZodOptional<z.ZodString>;
		giveFeedback: z.ZodOptional<z.ZodString>;
		sendFeedback: z.ZodOptional<z.ZodString>;
		feedbackFormTitle: z.ZodOptional<z.ZodString>;
		feedbackFormMessage: z.ZodOptional<z.ZodString>;
		feedbackFormMessagePlaceholder: z.ZodOptional<z.ZodString>;
		feedbackFormEmail: z.ZodOptional<z.ZodString>;
		feedbackFormEmailPlaceholder: z.ZodOptional<z.ZodString>;
		askQuestionAgain: z.ZodOptional<z.ZodString>;
		answerGood: z.ZodOptional<z.ZodString>;
		answerBad: z.ZodOptional<z.ZodString>;
		classificationSubmit: z.ZodOptional<z.ZodString>;
		classificationThankYou: z.ZodOptional<z.ZodString>;
		classificationTitle: z.ZodOptional<z.ZodString>;
		selectLanguage: z.ZodOptional<z.ZodString>;
		languageChanged: z.ZodOptional<z.ZodString>;
		selectColorTheme: z.ZodOptional<z.ZodString>;
		lightMode: z.ZodOptional<z.ZodString>;
		darkMode: z.ZodOptional<z.ZodString>;
		ariaMainNavigation: z.ZodOptional<z.ZodString>;
		ariaMainNavigationRegion: z.ZodOptional<z.ZodString>;
		ariaGotoMainNavigation: z.ZodOptional<z.ZodString>;
		ariaAskQuestion: z.ZodOptional<z.ZodString>;
		ariaAskQuestionRegion: z.ZodOptional<z.ZodString>;
		ariaNotifications: z.ZodOptional<z.ZodString>;
		ariaPredefinedQuestions: z.ZodOptional<z.ZodString>;
		ariaPredefinedQuestionsRegion: z.ZodOptional<z.ZodString>;
		ariaChatHistory: z.ZodOptional<z.ZodString>;
		ariaOpenChat: z.ZodOptional<z.ZodString>;
		ariaQuestionFromYou: z.ZodOptional<z.ZodString>;
		ariaAnswerFromBot: z.ZodOptional<z.ZodString>;
		ariaLastAnswerNavigation: z.ZodOptional<z.ZodString>;
		ariaQuestionSent: z.ZodOptional<z.ZodString>;
		ariaAnswerReady: z.ZodOptional<z.ZodString>;
		ariaAnswerFinished: z.ZodOptional<z.ZodString>;
		ariaAskQuestionAgain: z.ZodOptional<z.ZodString>;
		ariaAnswerGood: z.ZodOptional<z.ZodString>;
		ariaAnswerBad: z.ZodOptional<z.ZodString>;
		ariaReferenceSource: z.ZodOptional<z.ZodString>;
		ariaGiveFeedback: z.ZodOptional<z.ZodString>;
		ariaLanguageChanged: z.ZodOptional<z.ZodString>;
		ariaLightSelected: z.ZodOptional<z.ZodString>;
		ariaDarkSelected: z.ZodOptional<z.ZodString>;
		ariaSettings: z.ZodOptional<z.ZodString>;
		ariaSettingsRegion: z.ZodOptional<z.ZodString>;
		ariaReferencesRegion: z.ZodOptional<z.ZodString>;
		ariaOpensInNewTab: z.ZodOptional<z.ZodString>;
		ariaFlyoutRegion: z.ZodOptional<z.ZodString>;
		ariaSelected: z.ZodOptional<z.ZodString>;
		ariaUnselected: z.ZodOptional<z.ZodString>;
		ariaAllSelected: z.ZodOptional<z.ZodString>;
		ariaAllUnselected: z.ZodOptional<z.ZodString>;
		ariaAllReseted: z.ZodOptional<z.ZodString>;
		popups: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
			hash: z.ZodString;
			title: z.ZodString;
			content: z.ZodString;
			actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
				action: z.ZodString;
				label: z.ZodString;
				type: z.ZodOptional<z.ZodEnum<{
					primary: "primary";
					secondary: "secondary";
				}>>;
			}, z.core.$strip>>>;
		}, z.core.$strip>>>>;
		termsAcceptButton: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		termsReadButton: z.ZodOptional<z.ZodOptional<z.ZodString>>;
		hideSettings: z.ZodOptional<z.ZodString>;
		showSettings: z.ZodOptional<z.ZodString>;
		chooseAtLeastOneOption: z.ZodOptional<z.ZodString>;
		selectAll: z.ZodOptional<z.ZodString>;
		selectNone: z.ZodOptional<z.ZodString>;
		resetToDefaults: z.ZodOptional<z.ZodString>;
		messageTooLong: z.ZodOptional<z.ZodString>;
		selectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
			name: z.ZodString;
			namePlural: z.ZodOptional<z.ZodString>;
			intro: z.ZodOptional<z.ZodString>;
			placeholder: z.ZodString;
			values: z.ZodRecord<z.ZodString, z.ZodString>;
		}, z.core.$strip>>>;
	}, z.core.$strip>>>;
	buttonHref: z.ZodOptional<z.ZodOptional<z.ZodString>>;
	addQueryToUrlParams: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
	addRetrievalQuestionToUrlParams: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
	renderKatex: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
	reflectLanguageInPath: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
	sendReferrer: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
		all: "all";
		own: "own";
		none: "none";
		location: "location";
	}>>>;
	selectorsConfig: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
		settingName: z.ZodString;
		iconName: z.ZodString;
		settingIntro: z.ZodOptional<z.ZodString>;
		type: z.ZodEnum<{
			"single-select": "single-select";
			"multi-select": "multi-select";
		}>;
		allowEmpty: z.ZodBoolean;
		values: z.ZodArray<z.ZodString>;
		defaultValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
	}, z.core.$strip>>>>;
	questionLengthLimit: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
	forceConsent: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
	askQuestionAgain: z.ZodOptional<z.ZodBoolean>;
	enableBackdrop: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
	messageAdditions: z.ZodOptional<z.ZodOptional<z.ZodObject<{
		init: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [
			z.ZodUnion<readonly [
				z.ZodObject<{
					type: z.ZodLiteral<"bot">;
					time: z.ZodString;
					id: z.ZodString;
					message: z.ZodObject<{
						markdown: z.ZodString;
						html: z.ZodString;
						text: z.ZodString;
					}, z.core.$strip>;
					references: z.ZodObject<{
						all: z.ZodArray<z.ZodObject<{
							url: z.ZodString;
							score: z.ZodNumber;
							metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
								z.ZodString,
								z.ZodNumber,
								z.ZodBoolean,
								z.ZodArray<z.ZodString>,
								z.ZodArray<z.ZodNumber>,
								z.ZodArray<z.ZodBoolean>
							]>>;
							considered: z.ZodBoolean;
							display: z.ZodObject<{
								card: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
								listItem: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
							}, z.core.$strip>;
							referenceIndex: z.ZodObject<{
								all: z.ZodNumber;
								used: z.ZodOptional<z.ZodNumber>;
							}, z.core.$strip>;
						}, z.core.$strip>>;
						used: z.ZodArray<z.ZodObject<{
							url: z.ZodString;
							score: z.ZodNumber;
							metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
								z.ZodString,
								z.ZodNumber,
								z.ZodBoolean,
								z.ZodArray<z.ZodString>,
								z.ZodArray<z.ZodNumber>,
								z.ZodArray<z.ZodBoolean>
							]>>;
							considered: z.ZodBoolean;
							display: z.ZodObject<{
								card: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
								listItem: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
							}, z.core.$strip>;
							referenceIndex: z.ZodObject<{
								all: z.ZodNumber;
								used: z.ZodOptional<z.ZodNumber>;
							}, z.core.$strip>;
						}, z.core.$strip>>;
						unused: z.ZodArray<z.ZodObject<{
							url: z.ZodString;
							score: z.ZodNumber;
							metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
								z.ZodString,
								z.ZodNumber,
								z.ZodBoolean,
								z.ZodArray<z.ZodString>,
								z.ZodArray<z.ZodNumber>,
								z.ZodArray<z.ZodBoolean>
							]>>;
							considered: z.ZodBoolean;
							display: z.ZodObject<{
								card: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
								listItem: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
							}, z.core.$strip>;
							referenceIndex: z.ZodObject<{
								all: z.ZodNumber;
								used: z.ZodOptional<z.ZodNumber>;
							}, z.core.$strip>;
						}, z.core.$strip>>;
					}, z.core.$strip>;
					errors: z.ZodArray<z.ZodUnion<readonly [
						z.ZodEnum<{
							"pii-detected": "pii-detected";
							blocked: "blocked";
							maintenance: "maintenance";
							"rate-limit": "rate-limit";
							"server-error": "server-error";
							"too-short": "too-short";
							"too-long": "too-long";
							"quota-reached": "quota-reached";
							aborted: "aborted";
						}>,
						z.ZodLiteral<"sse-error">,
						z.ZodLiteral<"client-error">,
						z.ZodLiteral<"unexpected-call">
					]>>;
					retrievalQuestion: z.ZodOptional<z.ZodString>;
					state: z.ZodLiteral<"loading">;
				}, z.core.$strip>,
				z.ZodObject<{
					type: z.ZodLiteral<"bot">;
					time: z.ZodString;
					id: z.ZodString;
					message: z.ZodObject<{
						markdown: z.ZodString;
						html: z.ZodString;
						text: z.ZodString;
					}, z.core.$strip>;
					references: z.ZodObject<{
						all: z.ZodArray<z.ZodObject<{
							url: z.ZodString;
							score: z.ZodNumber;
							metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
								z.ZodString,
								z.ZodNumber,
								z.ZodBoolean,
								z.ZodArray<z.ZodString>,
								z.ZodArray<z.ZodNumber>,
								z.ZodArray<z.ZodBoolean>
							]>>;
							considered: z.ZodBoolean;
							display: z.ZodObject<{
								card: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
								listItem: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
							}, z.core.$strip>;
							referenceIndex: z.ZodObject<{
								all: z.ZodNumber;
								used: z.ZodOptional<z.ZodNumber>;
							}, z.core.$strip>;
						}, z.core.$strip>>;
						used: z.ZodArray<z.ZodObject<{
							url: z.ZodString;
							score: z.ZodNumber;
							metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
								z.ZodString,
								z.ZodNumber,
								z.ZodBoolean,
								z.ZodArray<z.ZodString>,
								z.ZodArray<z.ZodNumber>,
								z.ZodArray<z.ZodBoolean>
							]>>;
							considered: z.ZodBoolean;
							display: z.ZodObject<{
								card: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
								listItem: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
							}, z.core.$strip>;
							referenceIndex: z.ZodObject<{
								all: z.ZodNumber;
								used: z.ZodOptional<z.ZodNumber>;
							}, z.core.$strip>;
						}, z.core.$strip>>;
						unused: z.ZodArray<z.ZodObject<{
							url: z.ZodString;
							score: z.ZodNumber;
							metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
								z.ZodString,
								z.ZodNumber,
								z.ZodBoolean,
								z.ZodArray<z.ZodString>,
								z.ZodArray<z.ZodNumber>,
								z.ZodArray<z.ZodBoolean>
							]>>;
							considered: z.ZodBoolean;
							display: z.ZodObject<{
								card: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
								listItem: z.ZodObject<{
									title: z.ZodString;
									description: z.ZodOptional<z.ZodString>;
									badge: z.ZodOptional<z.ZodString>;
									breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
									previewImage: z.ZodOptional<z.ZodString>;
									date: z.ZodOptional<z.ZodString>;
								}, z.core.$strip>;
							}, z.core.$strip>;
							referenceIndex: z.ZodObject<{
								all: z.ZodNumber;
								used: z.ZodOptional<z.ZodNumber>;
							}, z.core.$strip>;
						}, z.core.$strip>>;
					}, z.core.$strip>;
					errors: z.ZodArray<z.ZodUnion<readonly [
						z.ZodEnum<{
							"pii-detected": "pii-detected";
							blocked: "blocked";
							maintenance: "maintenance";
							"rate-limit": "rate-limit";
							"server-error": "server-error";
							"too-short": "too-short";
							"too-long": "too-long";
							"quota-reached": "quota-reached";
							aborted: "aborted";
						}>,
						z.ZodLiteral<"sse-error">,
						z.ZodLiteral<"client-error">,
						z.ZodLiteral<"unexpected-call">
					]>>;
					retrievalQuestion: z.ZodOptional<z.ZodString>;
					state: z.ZodEnum<{
						streaming: "streaming";
						done: "done";
					}>;
				}, z.core.$strip>
			]>,
			z.ZodObject<{
				type: z.ZodLiteral<"user">;
				time: z.ZodString;
				message: z.ZodString;
				id: z.ZodOptional<z.ZodString>;
			}, z.core.$strip>,
			z.ZodIntersection<z.ZodDiscriminatedUnion<[
				z.ZodObject<{
					componentName: z.ZodLiteral<"buttons">;
					data: z.ZodObject<{
						caption: z.ZodOptional<z.ZodString>;
						buttons: z.ZodArray<z.ZodObject<{
							label: z.ZodString;
							href: z.ZodOptional<z.ZodString>;
							value: z.ZodString;
							variant: z.ZodOptional<z.ZodEnum<{
								primary: "primary";
								secondary: "secondary";
								tertiary: "tertiary";
							}>>;
							icon: z.ZodOptional<z.ZodString>;
							target: z.ZodOptional<z.ZodString>;
						}, z.core.$strip>>;
					}, z.core.$strip>;
				}, z.core.$strip>,
				z.ZodObject<{
					componentName: z.ZodLiteral<"combobox">;
					data: z.ZodObject<{
						caption: z.ZodOptional<z.ZodString>;
						placeholder: z.ZodString;
						values: z.ZodArray<z.ZodObject<{
							label: z.ZodString;
							value: z.ZodString;
						}, z.core.$strip>>;
					}, z.core.$strip>;
				}, z.core.$strip>,
				z.ZodObject<{
					componentName: z.ZodLiteral<"alva-init">;
					data: z.ZodObject<{}, z.core.$strip>;
				}, z.core.$strip>,
				z.ZodObject<{
					componentName: z.ZodLiteral<"alva-score-survey">;
					data: z.ZodObject<{}, z.core.$strip>;
				}, z.core.$strip>
			], "componentName">, z.ZodObject<{
				type: z.ZodLiteral<"component">;
				id: z.ZodOptional<z.ZodString>;
				time: z.ZodOptional<z.ZodString>;
				hideAvatar: z.ZodOptional<z.ZodBoolean>;
				noSectionPadding: z.ZodOptional<z.ZodBoolean>;
			}, z.core.$strip>>
		]>>>;
		bot: z.ZodOptional<z.ZodObject<{
			before: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [
				z.ZodUnion<readonly [
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodLiteral<"loading">;
					}, z.core.$strip>,
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodEnum<{
							streaming: "streaming";
							done: "done";
						}>;
					}, z.core.$strip>
				]>,
				z.ZodObject<{
					type: z.ZodLiteral<"user">;
					time: z.ZodString;
					message: z.ZodString;
					id: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>,
				z.ZodIntersection<z.ZodDiscriminatedUnion<[
					z.ZodObject<{
						componentName: z.ZodLiteral<"buttons">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							buttons: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								href: z.ZodOptional<z.ZodString>;
								value: z.ZodString;
								variant: z.ZodOptional<z.ZodEnum<{
									primary: "primary";
									secondary: "secondary";
									tertiary: "tertiary";
								}>>;
								icon: z.ZodOptional<z.ZodString>;
								target: z.ZodOptional<z.ZodString>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"combobox">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							placeholder: z.ZodString;
							values: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								value: z.ZodString;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-init">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-score-survey">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>
				], "componentName">, z.ZodObject<{
					type: z.ZodLiteral<"component">;
					id: z.ZodOptional<z.ZodString>;
					time: z.ZodOptional<z.ZodString>;
					hideAvatar: z.ZodOptional<z.ZodBoolean>;
					noSectionPadding: z.ZodOptional<z.ZodBoolean>;
				}, z.core.$strip>>
			]>>>;
			after: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [
				z.ZodUnion<readonly [
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodLiteral<"loading">;
					}, z.core.$strip>,
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodEnum<{
							streaming: "streaming";
							done: "done";
						}>;
					}, z.core.$strip>
				]>,
				z.ZodObject<{
					type: z.ZodLiteral<"user">;
					time: z.ZodString;
					message: z.ZodString;
					id: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>,
				z.ZodIntersection<z.ZodDiscriminatedUnion<[
					z.ZodObject<{
						componentName: z.ZodLiteral<"buttons">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							buttons: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								href: z.ZodOptional<z.ZodString>;
								value: z.ZodString;
								variant: z.ZodOptional<z.ZodEnum<{
									primary: "primary";
									secondary: "secondary";
									tertiary: "tertiary";
								}>>;
								icon: z.ZodOptional<z.ZodString>;
								target: z.ZodOptional<z.ZodString>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"combobox">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							placeholder: z.ZodString;
							values: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								value: z.ZodString;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-init">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-score-survey">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>
				], "componentName">, z.ZodObject<{
					type: z.ZodLiteral<"component">;
					id: z.ZodOptional<z.ZodString>;
					time: z.ZodOptional<z.ZodString>;
					hideAvatar: z.ZodOptional<z.ZodBoolean>;
					noSectionPadding: z.ZodOptional<z.ZodBoolean>;
				}, z.core.$strip>>
			]>>>;
		}, z.core.$strip>>;
		user: z.ZodOptional<z.ZodObject<{
			before: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [
				z.ZodUnion<readonly [
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodLiteral<"loading">;
					}, z.core.$strip>,
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodEnum<{
							streaming: "streaming";
							done: "done";
						}>;
					}, z.core.$strip>
				]>,
				z.ZodObject<{
					type: z.ZodLiteral<"user">;
					time: z.ZodString;
					message: z.ZodString;
					id: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>,
				z.ZodIntersection<z.ZodDiscriminatedUnion<[
					z.ZodObject<{
						componentName: z.ZodLiteral<"buttons">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							buttons: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								href: z.ZodOptional<z.ZodString>;
								value: z.ZodString;
								variant: z.ZodOptional<z.ZodEnum<{
									primary: "primary";
									secondary: "secondary";
									tertiary: "tertiary";
								}>>;
								icon: z.ZodOptional<z.ZodString>;
								target: z.ZodOptional<z.ZodString>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"combobox">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							placeholder: z.ZodString;
							values: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								value: z.ZodString;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-init">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-score-survey">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>
				], "componentName">, z.ZodObject<{
					type: z.ZodLiteral<"component">;
					id: z.ZodOptional<z.ZodString>;
					time: z.ZodOptional<z.ZodString>;
					hideAvatar: z.ZodOptional<z.ZodBoolean>;
					noSectionPadding: z.ZodOptional<z.ZodBoolean>;
				}, z.core.$strip>>
			]>>>;
			after: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [
				z.ZodUnion<readonly [
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodLiteral<"loading">;
					}, z.core.$strip>,
					z.ZodObject<{
						type: z.ZodLiteral<"bot">;
						time: z.ZodString;
						id: z.ZodString;
						message: z.ZodObject<{
							markdown: z.ZodString;
							html: z.ZodString;
							text: z.ZodString;
						}, z.core.$strip>;
						references: z.ZodObject<{
							all: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							used: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
							unused: z.ZodArray<z.ZodObject<{
								url: z.ZodString;
								score: z.ZodNumber;
								metadata: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
									z.ZodString,
									z.ZodNumber,
									z.ZodBoolean,
									z.ZodArray<z.ZodString>,
									z.ZodArray<z.ZodNumber>,
									z.ZodArray<z.ZodBoolean>
								]>>;
								considered: z.ZodBoolean;
								display: z.ZodObject<{
									card: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
									listItem: z.ZodObject<{
										title: z.ZodString;
										description: z.ZodOptional<z.ZodString>;
										badge: z.ZodOptional<z.ZodString>;
										breadcrumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
										previewImage: z.ZodOptional<z.ZodString>;
										date: z.ZodOptional<z.ZodString>;
									}, z.core.$strip>;
								}, z.core.$strip>;
								referenceIndex: z.ZodObject<{
									all: z.ZodNumber;
									used: z.ZodOptional<z.ZodNumber>;
								}, z.core.$strip>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
						errors: z.ZodArray<z.ZodUnion<readonly [
							z.ZodEnum<{
								"pii-detected": "pii-detected";
								blocked: "blocked";
								maintenance: "maintenance";
								"rate-limit": "rate-limit";
								"server-error": "server-error";
								"too-short": "too-short";
								"too-long": "too-long";
								"quota-reached": "quota-reached";
								aborted: "aborted";
							}>,
							z.ZodLiteral<"sse-error">,
							z.ZodLiteral<"client-error">,
							z.ZodLiteral<"unexpected-call">
						]>>;
						retrievalQuestion: z.ZodOptional<z.ZodString>;
						state: z.ZodEnum<{
							streaming: "streaming";
							done: "done";
						}>;
					}, z.core.$strip>
				]>,
				z.ZodObject<{
					type: z.ZodLiteral<"user">;
					time: z.ZodString;
					message: z.ZodString;
					id: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>,
				z.ZodIntersection<z.ZodDiscriminatedUnion<[
					z.ZodObject<{
						componentName: z.ZodLiteral<"buttons">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							buttons: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								href: z.ZodOptional<z.ZodString>;
								value: z.ZodString;
								variant: z.ZodOptional<z.ZodEnum<{
									primary: "primary";
									secondary: "secondary";
									tertiary: "tertiary";
								}>>;
								icon: z.ZodOptional<z.ZodString>;
								target: z.ZodOptional<z.ZodString>;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"combobox">;
						data: z.ZodObject<{
							caption: z.ZodOptional<z.ZodString>;
							placeholder: z.ZodString;
							values: z.ZodArray<z.ZodObject<{
								label: z.ZodString;
								value: z.ZodString;
							}, z.core.$strip>>;
						}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-init">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>,
					z.ZodObject<{
						componentName: z.ZodLiteral<"alva-score-survey">;
						data: z.ZodObject<{}, z.core.$strip>;
					}, z.core.$strip>
				], "componentName">, z.ZodObject<{
					type: z.ZodLiteral<"component">;
					id: z.ZodOptional<z.ZodString>;
					time: z.ZodOptional<z.ZodString>;
					hideAvatar: z.ZodOptional<z.ZodBoolean>;
					noSectionPadding: z.ZodOptional<z.ZodBoolean>;
				}, z.core.$strip>>
			]>>>;
		}, z.core.$strip>>;
	}, z.core.$strip>>>;
	contextVersion: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
}, z.core.$strip>;
export type ChatConfig = z.infer<typeof chatConfigSchema>;
declare const themeSchema: z.ZodObject<{
	avatarImageUrl: z.ZodOptional<z.ZodString>;
	colors: z.ZodOptional<z.ZodObject<{
		brand: z.ZodOptional<z.ZodUnion<readonly [
			z.ZodObject<{
				"50": z.ZodString;
				"100": z.ZodString;
				"200": z.ZodString;
				"300": z.ZodString;
				"400": z.ZodString;
				"500": z.ZodString;
				"600": z.ZodString;
				"700": z.ZodString;
				"800": z.ZodString;
				"900": z.ZodString;
				"950": z.ZodString;
			}, z.core.$strip>,
			z.ZodEnum<{
				slate: "slate";
				gray: "gray";
				zinc: "zinc";
				neutral: "neutral";
				stone: "stone";
				red: "red";
				orange: "orange";
				amber: "amber";
				yellow: "yellow";
				lime: "lime";
				green: "green";
				emerald: "emerald";
				teal: "teal";
				cyan: "cyan";
				sky: "sky";
				blue: "blue";
				indigo: "indigo";
				violet: "violet";
				purple: "purple";
				fuchsia: "fuchsia";
				pink: "pink";
				rose: "rose";
			}>
		]>>;
		highlight: z.ZodOptional<z.ZodUnion<readonly [
			z.ZodObject<{
				"50": z.ZodString;
				"100": z.ZodString;
				"200": z.ZodString;
				"300": z.ZodString;
				"400": z.ZodString;
				"500": z.ZodString;
				"600": z.ZodString;
				"700": z.ZodString;
				"800": z.ZodString;
				"900": z.ZodString;
				"950": z.ZodString;
			}, z.core.$strip>,
			z.ZodEnum<{
				slate: "slate";
				gray: "gray";
				zinc: "zinc";
				neutral: "neutral";
				stone: "stone";
				red: "red";
				orange: "orange";
				amber: "amber";
				yellow: "yellow";
				lime: "lime";
				green: "green";
				emerald: "emerald";
				teal: "teal";
				cyan: "cyan";
				sky: "sky";
				blue: "blue";
				indigo: "indigo";
				violet: "violet";
				purple: "purple";
				fuchsia: "fuchsia";
				pink: "pink";
				rose: "rose";
			}>
		]>>;
		grey: z.ZodOptional<z.ZodUnion<readonly [
			z.ZodIntersection<z.ZodObject<{
				"50": z.ZodString;
				"100": z.ZodString;
				"200": z.ZodString;
				"300": z.ZodString;
				"400": z.ZodString;
				"500": z.ZodString;
				"600": z.ZodString;
				"700": z.ZodString;
				"800": z.ZodString;
				"900": z.ZodString;
				"950": z.ZodString;
			}, z.core.$strip>, z.ZodObject<{
				"0": z.ZodString;
				"1000": z.ZodString;
			}, z.core.$strip>>,
			z.ZodEnum<{
				slate: "slate";
				gray: "gray";
				zinc: "zinc";
				neutral: "neutral";
				stone: "stone";
				red: "red";
				orange: "orange";
				amber: "amber";
				yellow: "yellow";
				lime: "lime";
				green: "green";
				emerald: "emerald";
				teal: "teal";
				cyan: "cyan";
				sky: "sky";
				blue: "blue";
				indigo: "indigo";
				violet: "violet";
				purple: "purple";
				fuchsia: "fuchsia";
				pink: "pink";
				rose: "rose";
			}>
		]>>;
		background: z.ZodOptional<z.ZodString>;
		text: z.ZodOptional<z.ZodString>;
		anchor: z.ZodOptional<z.ZodObject<{
			default: z.ZodOptional<z.ZodString>;
			hover: z.ZodOptional<z.ZodString>;
		}, z.core.$strip>>;
	}, z.core.$strip>>;
	font: z.ZodOptional<z.ZodObject<{
		family: z.ZodOptional<z.ZodString>;
		urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
		sizeXs: z.ZodOptional<z.ZodUnion<[
			z.ZodObject<{
				minRem: z.ZodNumber;
				maxRem: z.ZodNumber;
			}, z.core.$strip>,
			z.ZodString
		]>>;
		sizeSm: z.ZodOptional<z.ZodUnion<[
			z.ZodObject<{
				minRem: z.ZodNumber;
				maxRem: z.ZodNumber;
			}, z.core.$strip>,
			z.ZodString
		]>>;
		sizeBody: z.ZodOptional<z.ZodUnion<[
			z.ZodObject<{
				minRem: z.ZodNumber;
				maxRem: z.ZodNumber;
			}, z.core.$strip>,
			z.ZodString
		]>>;
		sizeH3: z.ZodOptional<z.ZodUnion<[
			z.ZodObject<{
				minRem: z.ZodNumber;
				maxRem: z.ZodNumber;
			}, z.core.$strip>,
			z.ZodString
		]>>;
		sizeH2: z.ZodOptional<z.ZodUnion<[
			z.ZodObject<{
				minRem: z.ZodNumber;
				maxRem: z.ZodNumber;
			}, z.core.$strip>,
			z.ZodString
		]>>;
		sizeH1: z.ZodOptional<z.ZodUnion<[
			z.ZodObject<{
				minRem: z.ZodNumber;
				maxRem: z.ZodNumber;
			}, z.core.$strip>,
			z.ZodString
		]>>;
		weightNormal: z.ZodOptional<z.ZodString>;
		weightBold: z.ZodOptional<z.ZodString>;
		weightTitle: z.ZodOptional<z.ZodString>;
	}, z.core.$strip>>;
	borderRadius: z.ZodOptional<z.ZodUnion<[
		z.ZodObject<{
			minRem: z.ZodNumber;
			maxRem: z.ZodNumber;
		}, z.core.$strip>,
		z.ZodString
	]>>;
	fineGrained: z.ZodOptional<z.ZodObject<{
		light: z.ZodOptional<z.ZodObject<{
			customCSS: z.ZodOptional<z.ZodString>;
			fontCSS: z.ZodOptional<z.ZodString>;
			fontURLs: z.ZodOptional<z.ZodArray<z.ZodString>>;
			tokens: z.ZodOptional<z.ZodObject<{
				font: z.ZodOptional<z.ZodObject<{
					family: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>>;
				colors: z.ZodOptional<z.ZodObject<{
					brand: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
					accent: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
					highlight: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
					grey: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
				}, z.core.$strip>>;
				base: z.ZodOptional<z.ZodObject<{
					fontSizeXs: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeSm: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeBody: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeH3: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeH2: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeH1: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontWeightNormal: z.ZodOptional<z.ZodString>;
					fontWeightBold: z.ZodOptional<z.ZodString>;
					fontWeightTitle: z.ZodOptional<z.ZodString>;
					lineHeightDefault: z.ZodOptional<z.ZodString>;
					lineHeightSnug: z.ZodOptional<z.ZodString>;
					lineHeightTight: z.ZodOptional<z.ZodString>;
					borderRadius: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					lineColor: z.ZodOptional<z.ZodString>;
					boxShadow: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>>;
				components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodObject<{
					borderRadius: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
						z.ZodString,
						z.ZodNumber
					]>>>;
					hover: z.ZodOptional<z.ZodObject<{
						color: z.ZodOptional<z.ZodString>;
						background: z.ZodOptional<z.ZodString>;
						borderWidth: z.ZodOptional<z.ZodString>;
						borderColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
					focus: z.ZodOptional<z.ZodObject<{
						color: z.ZodOptional<z.ZodString>;
						background: z.ZodOptional<z.ZodString>;
						borderWidth: z.ZodOptional<z.ZodString>;
						borderColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
				}, z.core.$strip>, z.ZodObject<{
					color: z.ZodOptional<z.ZodString>;
					background: z.ZodOptional<z.ZodString>;
					borderWidth: z.ZodOptional<z.ZodString>;
					borderColor: z.ZodOptional<z.ZodString>;
					boxShadow: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>>>>;
				svgs: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
					record: "record";
					abort: "abort";
					message: "message";
					lightMode: "lightMode";
					darkMode: "darkMode";
					audio: "audio";
					menu: "menu";
					copy: "copy";
					submit: "submit";
					predefinedQuestion: "predefinedQuestion";
					edit: "edit";
					newConversation: "newConversation";
					voteUp: "voteUp";
					voteDown: "voteDown";
					retry: "retry";
					messageLoading: "messageLoading";
					thread: "thread";
					expand: "expand";
					help: "help";
					attach: "attach";
					reward: "reward";
					share: "share";
					dismiss: "dismiss";
					info: "info";
					menuClose: "menuClose";
					chevronDown: "chevronDown";
					chevronUp: "chevronUp";
					chevronTopDown: "chevronTopDown";
					chevronDownSmall: "chevronDownSmall";
					internalLink: "internalLink";
					externalLink: "externalLink";
					liip: "liip";
					avatar: "avatar";
					avatarLarge: "avatarLarge";
					openChat: "openChat";
					speechInput: "speechInput";
					listUnordered: "listUnordered";
					settings: "settings";
					settingsClose: "settingsClose";
					sources: "sources";
					model: "model";
					checkbox: "checkbox";
					warning: "warning";
					headerLogo: "headerLogo";
					embedAvatar: "embedAvatar";
				}> & z.core.$partial, z.ZodString>>;
			}, z.core.$strip>>;
		}, z.core.$strip>>;
		dark: z.ZodOptional<z.ZodObject<{
			customCSS: z.ZodOptional<z.ZodString>;
			fontCSS: z.ZodOptional<z.ZodString>;
			fontURLs: z.ZodOptional<z.ZodArray<z.ZodString>>;
			tokens: z.ZodOptional<z.ZodObject<{
				font: z.ZodOptional<z.ZodObject<{
					family: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>>;
				colors: z.ZodOptional<z.ZodObject<{
					brand: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
					accent: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
					highlight: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
					grey: z.ZodOptional<z.ZodObject<{
						0: z.ZodOptional<z.ZodOptional<z.ZodString>>;
						50: z.ZodOptional<z.ZodString>;
						100: z.ZodOptional<z.ZodString>;
						200: z.ZodOptional<z.ZodString>;
						300: z.ZodOptional<z.ZodString>;
						400: z.ZodOptional<z.ZodString>;
						500: z.ZodOptional<z.ZodString>;
						600: z.ZodOptional<z.ZodString>;
						700: z.ZodOptional<z.ZodString>;
						800: z.ZodOptional<z.ZodString>;
						900: z.ZodOptional<z.ZodString>;
						950: z.ZodOptional<z.ZodString>;
						1000: z.ZodOptional<z.ZodOptional<z.ZodString>>;
					}, z.core.$strip>>;
				}, z.core.$strip>>;
				base: z.ZodOptional<z.ZodObject<{
					fontSizeXs: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeSm: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeBody: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeH3: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeH2: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontSizeH1: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					fontWeightNormal: z.ZodOptional<z.ZodString>;
					fontWeightBold: z.ZodOptional<z.ZodString>;
					fontWeightTitle: z.ZodOptional<z.ZodString>;
					lineHeightDefault: z.ZodOptional<z.ZodString>;
					lineHeightSnug: z.ZodOptional<z.ZodString>;
					lineHeightTight: z.ZodOptional<z.ZodString>;
					borderRadius: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					lineColor: z.ZodOptional<z.ZodString>;
					boxShadow: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>>;
				components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodObject<{
					borderRadius: z.ZodOptional<z.ZodUnion<[
						z.ZodObject<{
							minRem: z.ZodNumber;
							maxRem: z.ZodNumber;
						}, z.core.$strip>,
						z.ZodString
					]>>;
					custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
						z.ZodString,
						z.ZodNumber
					]>>>;
					hover: z.ZodOptional<z.ZodObject<{
						color: z.ZodOptional<z.ZodString>;
						background: z.ZodOptional<z.ZodString>;
						borderWidth: z.ZodOptional<z.ZodString>;
						borderColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
					focus: z.ZodOptional<z.ZodObject<{
						color: z.ZodOptional<z.ZodString>;
						background: z.ZodOptional<z.ZodString>;
						borderWidth: z.ZodOptional<z.ZodString>;
						borderColor: z.ZodOptional<z.ZodString>;
						boxShadow: z.ZodOptional<z.ZodString>;
					}, z.core.$strip>>;
				}, z.core.$strip>, z.ZodObject<{
					color: z.ZodOptional<z.ZodString>;
					background: z.ZodOptional<z.ZodString>;
					borderWidth: z.ZodOptional<z.ZodString>;
					borderColor: z.ZodOptional<z.ZodString>;
					boxShadow: z.ZodOptional<z.ZodString>;
				}, z.core.$strip>>>>;
				svgs: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
					record: "record";
					abort: "abort";
					message: "message";
					lightMode: "lightMode";
					darkMode: "darkMode";
					audio: "audio";
					menu: "menu";
					copy: "copy";
					submit: "submit";
					predefinedQuestion: "predefinedQuestion";
					edit: "edit";
					newConversation: "newConversation";
					voteUp: "voteUp";
					voteDown: "voteDown";
					retry: "retry";
					messageLoading: "messageLoading";
					thread: "thread";
					expand: "expand";
					help: "help";
					attach: "attach";
					reward: "reward";
					share: "share";
					dismiss: "dismiss";
					info: "info";
					menuClose: "menuClose";
					chevronDown: "chevronDown";
					chevronUp: "chevronUp";
					chevronTopDown: "chevronTopDown";
					chevronDownSmall: "chevronDownSmall";
					internalLink: "internalLink";
					externalLink: "externalLink";
					liip: "liip";
					avatar: "avatar";
					avatarLarge: "avatarLarge";
					openChat: "openChat";
					speechInput: "speechInput";
					listUnordered: "listUnordered";
					settings: "settings";
					settingsClose: "settingsClose";
					sources: "sources";
					model: "model";
					checkbox: "checkbox";
					warning: "warning";
					headerLogo: "headerLogo";
					embedAvatar: "embedAvatar";
				}> & z.core.$partial, z.ZodString>>;
			}, z.core.$strip>>;
		}, z.core.$strip>>;
	}, z.core.$strip>>;
}, z.core.$strip>;
export type Theme = z.infer<typeof themeSchema>;
export type MetadataValue = string | number | boolean | string[] | number[] | boolean[];
export type ReferenceContent = {
	title: string;
	description?: string;
	badge?: string;
	breadcrumbs?: string[];
	previewImage?: string;
	/**  ISO 8601 date string */
	date?: string;
};
export type SearchResult = {
	url: string;
	score: number;
	language?: string | null;
	metadata: Record<string, MetadataValue>;
} & ReferenceContent;
type Theme$1 = SimplifyDeep<Theme>;
type ChatConfig$1 = SimplifyDeep<ChatConfig>;
type SearchResult$1 = SimplifyDeep<SearchResult>;
type Translations$1 = SimplifyDeep<Translations>;
type TranslationsPartial$1 = SimplifyDeep<TranslationsPartial>;
type LiipgptListeners$1 = SimplifyDeep<LiipgptListeners>;

declare namespace JSONSchema$1 {
	export { ArraySchema, BaseSchema, BooleanSchema, IntegerSchema, JSONSchema, NullSchema, NumberSchema, ObjectSchema, Schema, StringSchema, _JSONSchema };
}
declare namespace util {
	export { AnyFunc, AssertEqual, AssertExtends, AssertNotEqual, BIGINT_FORMAT_RANGES, BuiltIn, Class, CleanKey, Constructor, EmptyObject, EmptyToNever, EnumLike, EnumValue, Exactly, Extend, ExtractIndexSignature, Flatten, FromCleanMap, HasLength, HasSize, HashAlgorithm, HashEncoding, HashFormat, IPVersion, Identity, InexactPartial, IsAny, IsProp, JSONType, JWTAlgorithm, KeyOf, Keys, KeysArray, KeysEnum, Literal, LiteralArray, LoosePartial, MakePartial, MakeReadonly, MakeRequired, Mapped, Mask, MaybeAsync, MimeTypes, NUMBER_FORMAT_RANGES, NoNever, NoNeverKeys, NoUndefined, Normalize, Numeric, Omit$1 as Omit, OmitIndexSignature, OmitKeys, ParsedTypes, Prettify, Primitive, PrimitiveArray, PrimitiveSet, PropValues, SafeParseError, SafeParseResult, SafeParseSuccess, SchemaClass, SomeObject, ToCleanMap, ToEnum, TupleItems, Whatever, Writeable, aborted, allowsEval, assert, assertEqual, assertIs, assertNever, assertNotEqual, assignProp, base64ToUint8Array, base64urlToUint8Array, cached, captureStackTrace, cleanEnum, cleanRegex, clone, cloneDef, createTransparentProxy, defineLazy, esc, escapeRegex, extend, finalizeIssue, floatSafeRemainder, getElementAtPath, getEnumValues, getLengthableOrigin, getParsedType, getSizableOrigin, hexToUint8Array, isObject, isPlainObject, issue, joinValues, jsonStringifyReplacer, merge, mergeDefs, normalizeParams, nullish, numKeys, objectClone, omit, optionalKeys, parsedType, partial, pick, prefixIssues, primitiveTypes, promiseAllObject, propertyKeyTypes, randomString, required, safeExtend, shallowClone, slugify, stringifyPrimitive, uint8ArrayToBase64, uint8ArrayToBase64url, uint8ArrayToHex, unwrapMessage };
}
declare namespace coerce {
	export { ZodCoercedBigInt, ZodCoercedBoolean, ZodCoercedDate, ZodCoercedNumber, ZodCoercedString, bigint$2 as bigint, boolean$2 as boolean, date$3 as date, number$2 as number, string$2 as string };
}
declare namespace schemas {
	export { $InferEnumInput, $InferEnumOutput, $InferInnerFunctionType, $InferInnerFunctionTypeAsync, $InferObjectInput, $InferObjectOutput, $InferOuterFunctionType, $InferOuterFunctionTypeAsync, $InferTupleInputType, $InferTupleOutputType, $InferUnionInput, $InferUnionOutput, $InferZodRecordInput, $InferZodRecordOutput, $PartsToTemplateLiteral, $ZodAny, $ZodAnyDef, $ZodAnyInternals, $ZodArray, $ZodArrayDef, $ZodArrayInternals, $ZodBase64, $ZodBase64Def, $ZodBase64Internals, $ZodBase64URL, $ZodBase64URLDef, $ZodBase64URLInternals, $ZodBigInt, $ZodBigIntDef, $ZodBigIntFormat, $ZodBigIntFormatDef, $ZodBigIntFormatInternals, $ZodBigIntInternals, $ZodBoolean, $ZodBooleanDef, $ZodBooleanInternals, $ZodCIDRv4, $ZodCIDRv4Def, $ZodCIDRv4Internals, $ZodCIDRv6, $ZodCIDRv6Def, $ZodCIDRv6Internals, $ZodCUID, $ZodCUID2, $ZodCUID2Def, $ZodCUID2Internals, $ZodCUIDDef, $ZodCUIDInternals, $ZodCatch, $ZodCatchCtx, $ZodCatchDef, $ZodCatchInternals, $ZodCodec, $ZodCodecDef, $ZodCodecInternals, $ZodCustom, $ZodCustomDef, $ZodCustomInternals, $ZodCustomStringFormat, $ZodCustomStringFormatDef, $ZodCustomStringFormatInternals, $ZodDate, $ZodDateDef, $ZodDateInternals, $ZodDefault, $ZodDefaultDef, $ZodDefaultInternals, $ZodDiscriminatedUnion, $ZodDiscriminatedUnionDef, $ZodDiscriminatedUnionInternals, $ZodE164, $ZodE164Def, $ZodE164Internals, $ZodEmail, $ZodEmailDef, $ZodEmailInternals, $ZodEmoji, $ZodEmojiDef, $ZodEmojiInternals, $ZodEnum, $ZodEnumDef, $ZodEnumInternals, $ZodExactOptional, $ZodExactOptionalDef, $ZodExactOptionalInternals, $ZodFile, $ZodFileDef, $ZodFileInternals, $ZodFunction, $ZodFunctionArgs, $ZodFunctionDef, $ZodFunctionIn, $ZodFunctionInternals, $ZodFunctionOut, $ZodFunctionParams, $ZodGUID, $ZodGUIDDef, $ZodGUIDInternals, $ZodIPv4, $ZodIPv4Def, $ZodIPv4Internals, $ZodIPv6, $ZodIPv6Def, $ZodIPv6Internals, $ZodISODate, $ZodISODateDef, $ZodISODateInternals, $ZodISODateTime, $ZodISODateTimeDef, $ZodISODateTimeInternals, $ZodISODuration, $ZodISODurationDef, $ZodISODurationInternals, $ZodISOTime, $ZodISOTimeDef, $ZodISOTimeInternals, $ZodIntersection, $ZodIntersectionDef, $ZodIntersectionInternals, $ZodJWT, $ZodJWTDef, $ZodJWTInternals, $ZodKSUID, $ZodKSUIDDef, $ZodKSUIDInternals, $ZodLazy, $ZodLazyDef, $ZodLazyInternals, $ZodLiteral, $ZodLiteralDef, $ZodLiteralInternals, $ZodLooseShape, $ZodMAC, $ZodMACDef, $ZodMACInternals, $ZodMap, $ZodMapDef, $ZodMapInternals, $ZodNaN, $ZodNaNDef, $ZodNaNInternals, $ZodNanoID, $ZodNanoIDDef, $ZodNanoIDInternals, $ZodNever, $ZodNeverDef, $ZodNeverInternals, $ZodNonOptional, $ZodNonOptionalDef, $ZodNonOptionalInternals, $ZodNull, $ZodNullDef, $ZodNullInternals, $ZodNullable, $ZodNullableDef, $ZodNullableInternals, $ZodNumber, $ZodNumberDef, $ZodNumberFormat, $ZodNumberFormatDef, $ZodNumberFormatInternals, $ZodNumberInternals, $ZodObject, $ZodObjectConfig, $ZodObjectDef, $ZodObjectInternals, $ZodObjectJIT, $ZodOptional, $ZodOptionalDef, $ZodOptionalInternals, $ZodPipe, $ZodPipeDef, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultDef, $ZodPrefaultInternals, $ZodPromise, $ZodPromiseDef, $ZodPromiseInternals, $ZodReadonly, $ZodReadonlyDef, $ZodReadonlyInternals, $ZodRecord, $ZodRecordDef, $ZodRecordInternals, $ZodRecordKey, $ZodSet, $ZodSetDef, $ZodSetInternals, $ZodShape, $ZodStandardSchema, $ZodString, $ZodStringDef, $ZodStringFormat, $ZodStringFormatDef, $ZodStringFormatInternals, $ZodStringFormatTypes, $ZodStringInternals, $ZodSuccess, $ZodSuccessDef, $ZodSuccessInternals, $ZodSymbol, $ZodSymbolDef, $ZodSymbolInternals, $ZodTemplateLiteral, $ZodTemplateLiteralDef, $ZodTemplateLiteralInternals, $ZodTemplateLiteralPart, $ZodTransform, $ZodTransformDef, $ZodTransformInternals, $ZodTuple, $ZodTupleDef, $ZodTupleInternals, $ZodType, $ZodTypeDef, $ZodTypeInternals, $ZodTypes, $ZodULID, $ZodULIDDef, $ZodULIDInternals, $ZodURL, $ZodURLDef, $ZodURLInternals, $ZodUUID, $ZodUUIDDef, $ZodUUIDInternals, $ZodUndefined, $ZodUndefinedDef, $ZodUndefinedInternals, $ZodUnion, $ZodUnionDef, $ZodUnionInternals, $ZodUnknown, $ZodUnknownDef, $ZodUnknownInternals, $ZodVoid, $ZodVoidDef, $ZodVoidInternals, $ZodXID, $ZodXIDDef, $ZodXIDInternals, $ZodXor, $ZodXorInternals, $catchall, $loose, $partial, $strict, $strip, CheckFn, ConcatenateTupleOfStrings, ConvertPartsToStringTuple, File$1 as File, ParseContext, ParseContextInternal, ParsePayload, SomeType, ToTemplateLiteral, _$ZodType, _$ZodTypeInternals, clone, isValidBase64, isValidBase64URL, isValidJWT };
}
declare namespace regexes {
	export { _null as null, _undefined as undefined, base64, base64url, bigint, boolean, browserEmail, cidrv4, cidrv6, cuid, cuid2, date, datetime, domain, duration, e164, email, emoji, extendedDuration, guid, hex, hostname, html5Email, idnEmail, integer, ipv4, ipv6, ksuid, lowercase, mac, md5_base64, md5_base64url, md5_hex, nanoid, number, rfc5322Email, sha1_base64, sha1_base64url, sha1_hex, sha256_base64, sha256_base64url, sha256_hex, sha384_base64, sha384_base64url, sha384_hex, sha512_base64, sha512_base64url, sha512_hex, string, time, ulid, unicodeEmail, uppercase, uuid, uuid4, uuid6, uuid7, xid };
}
declare namespace locales {
	export { _default as ar, _default$1 as az, _default$10 as es, _default$11 as fa, _default$12 as fi, _default$13 as fr, _default$14 as frCA, _default$15 as he, _default$16 as hu, _default$17 as hy, _default$18 as id, _default$19 as is, _default$2 as be, _default$20 as it, _default$21 as ja, _default$22 as ka, _default$23 as kh, _default$24 as km, _default$25 as ko, _default$26 as lt, _default$27 as mk, _default$28 as ms, _default$29 as nl, _default$3 as bg, _default$30 as no, _default$31 as ota, _default$32 as ps, _default$33 as pl, _default$34 as pt, _default$35 as ru, _default$36 as sl, _default$37 as sv, _default$38 as ta, _default$39 as th, _default$4 as ca, _default$40 as tr, _default$41 as ua, _default$42 as uk, _default$43 as ur, _default$44 as uz, _default$45 as vi, _default$46 as zhCN, _default$47 as zhTW, _default$48 as yo, _default$5 as cs, _default$6 as da, _default$7 as de, _default$8 as en, _default$9 as eo };
}
declare namespace schemas$1 {
	export { SafeExtendShape, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodExactOptional, ZodFile, ZodFloat32, ZodFloat64, ZodFunction, ZodGUID, ZodIPv4, ZodIPv6, ZodInt, ZodInt32, ZodIntersection, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMAC, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPromise, ZodReadonly, ZodRecord, ZodSet, ZodStandardSchemaWithJSON$1 as ZodStandardSchemaWithJSON, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodUInt32, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, ZodXor, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _catch$1 as catch, _default$50 as _default, _enum$1 as enum, _function, _function as function, _instanceof as instanceof, _null$2 as null, _undefined$2 as undefined, _void$1 as void, any, array, base64$1 as base64, base64url$1 as base64url, bigint$1 as bigint, boolean$1 as boolean, check, cidrv4$1 as cidrv4, cidrv6$1 as cidrv6, codec, cuid$1 as cuid, cuid2$1 as cuid2, custom, date$1 as date, describe$1 as describe, discriminatedUnion, e164$1 as e164, email$1 as email, emoji$1 as emoji, exactOptional, file, float32, float64, guid$1 as guid, hash, hex$1 as hex, hostname$1 as hostname, httpUrl, int, int32, int64, intersection, ipv4$1 as ipv4, ipv6$1 as ipv6, json, jwt, keyof, ksuid$1 as ksuid, lazy, literal, looseObject, looseRecord, mac$1 as mac, map, meta$1 as meta, nan, nanoid$1 as nanoid, nativeEnum, never, nonoptional, nullable, nullish$1 as nullish, number$1 as number, object, optional, partialRecord, pipe, prefault, preprocess, promise, readonly, record, refine, set, strictObject, string$1 as string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, transform, tuple, uint32, uint64, ulid$1 as ulid, union, unknown, url, uuid$1 as uuid, uuidv4, uuidv6, uuidv7, xid$1 as xid, xor };
}
declare namespace core {
	export { $Decode, $DecodeAsync, $Encode, $EncodeAsync, $InferEnumInput, $InferEnumOutput, $InferInnerFunctionType, $InferInnerFunctionTypeAsync, $InferObjectInput, $InferObjectOutput, $InferOuterFunctionType, $InferOuterFunctionTypeAsync, $InferTupleInputType, $InferTupleOutputType, $InferUnionInput, $InferUnionOutput, $InferZodRecordInput, $InferZodRecordOutput, $Parse, $ParseAsync, $PartsToTemplateLiteral, $RefinementCtx, $SafeDecode, $SafeDecodeAsync, $SafeEncode, $SafeEncodeAsync, $SafeParse, $SafeParseAsync, $ZodAny, $ZodAnyDef, $ZodAnyInternals, $ZodAnyParams, $ZodArray, $ZodArrayDef, $ZodArrayInternals, $ZodArrayParams, $ZodAsyncError, $ZodBase64, $ZodBase64Def, $ZodBase64Internals, $ZodBase64Params, $ZodBase64URL, $ZodBase64URLDef, $ZodBase64URLInternals, $ZodBase64URLParams, $ZodBigInt, $ZodBigIntDef, $ZodBigIntFormat, $ZodBigIntFormatDef, $ZodBigIntFormatInternals, $ZodBigIntFormatParams, $ZodBigIntFormats, $ZodBigIntInternals, $ZodBigIntParams, $ZodBoolean, $ZodBooleanDef, $ZodBooleanInternals, $ZodBooleanParams, $ZodBranded, $ZodCIDRv4, $ZodCIDRv4Def, $ZodCIDRv4Internals, $ZodCIDRv4Params, $ZodCIDRv6, $ZodCIDRv6Def, $ZodCIDRv6Internals, $ZodCIDRv6Params, $ZodCUID, $ZodCUID2, $ZodCUID2Def, $ZodCUID2Internals, $ZodCUID2Params, $ZodCUIDDef, $ZodCUIDInternals, $ZodCUIDParams, $ZodCatch, $ZodCatchCtx, $ZodCatchDef, $ZodCatchInternals, $ZodCatchParams, $ZodCheck, $ZodCheckBase64Params, $ZodCheckBase64URLParams, $ZodCheckBigIntFormat, $ZodCheckBigIntFormatDef, $ZodCheckBigIntFormatInternals, $ZodCheckBigIntFormatParams, $ZodCheckCIDRv4Params, $ZodCheckCIDRv6Params, $ZodCheckCUID2Params, $ZodCheckCUIDParams, $ZodCheckDef, $ZodCheckE164Params, $ZodCheckEmailParams, $ZodCheckEmojiParams, $ZodCheckEndsWith, $ZodCheckEndsWithDef, $ZodCheckEndsWithInternals, $ZodCheckEndsWithParams, $ZodCheckGUIDParams, $ZodCheckGreaterThan, $ZodCheckGreaterThanDef, $ZodCheckGreaterThanInternals, $ZodCheckGreaterThanParams, $ZodCheckIPv4Params, $ZodCheckIPv6Params, $ZodCheckISODateParams, $ZodCheckISODateTimeParams, $ZodCheckISODurationParams, $ZodCheckISOTimeParams, $ZodCheckIncludes, $ZodCheckIncludesDef, $ZodCheckIncludesInternals, $ZodCheckIncludesParams, $ZodCheckInternals, $ZodCheckJWTParams, $ZodCheckKSUIDParams, $ZodCheckLengthEquals, $ZodCheckLengthEqualsDef, $ZodCheckLengthEqualsInternals, $ZodCheckLengthEqualsParams, $ZodCheckLessThan, $ZodCheckLessThanDef, $ZodCheckLessThanInternals, $ZodCheckLessThanParams, $ZodCheckLowerCase, $ZodCheckLowerCaseDef, $ZodCheckLowerCaseInternals, $ZodCheckLowerCaseParams, $ZodCheckMACParams, $ZodCheckMaxLength, $ZodCheckMaxLengthDef, $ZodCheckMaxLengthInternals, $ZodCheckMaxLengthParams, $ZodCheckMaxSize, $ZodCheckMaxSizeDef, $ZodCheckMaxSizeInternals, $ZodCheckMaxSizeParams, $ZodCheckMimeType, $ZodCheckMimeTypeDef, $ZodCheckMimeTypeInternals, $ZodCheckMimeTypeParams, $ZodCheckMinLength, $ZodCheckMinLengthDef, $ZodCheckMinLengthInternals, $ZodCheckMinLengthParams, $ZodCheckMinSize, $ZodCheckMinSizeDef, $ZodCheckMinSizeInternals, $ZodCheckMinSizeParams, $ZodCheckMultipleOf, $ZodCheckMultipleOfDef, $ZodCheckMultipleOfInternals, $ZodCheckMultipleOfParams, $ZodCheckNanoIDParams, $ZodCheckNumberFormat, $ZodCheckNumberFormatDef, $ZodCheckNumberFormatInternals, $ZodCheckNumberFormatParams, $ZodCheckOverwrite, $ZodCheckOverwriteDef, $ZodCheckOverwriteInternals, $ZodCheckProperty, $ZodCheckPropertyDef, $ZodCheckPropertyInternals, $ZodCheckPropertyParams, $ZodCheckRegex, $ZodCheckRegexDef, $ZodCheckRegexInternals, $ZodCheckRegexParams, $ZodCheckSizeEquals, $ZodCheckSizeEqualsDef, $ZodCheckSizeEqualsInternals, $ZodCheckSizeEqualsParams, $ZodCheckStartsWith, $ZodCheckStartsWithDef, $ZodCheckStartsWithInternals, $ZodCheckStartsWithParams, $ZodCheckStringFormat, $ZodCheckStringFormatDef, $ZodCheckStringFormatInternals, $ZodCheckStringFormatParams, $ZodCheckULIDParams, $ZodCheckURLParams, $ZodCheckUUIDParams, $ZodCheckUUIDv4Params, $ZodCheckUUIDv6Params, $ZodCheckUUIDv7Params, $ZodCheckUpperCase, $ZodCheckUpperCaseDef, $ZodCheckUpperCaseInternals, $ZodCheckUpperCaseParams, $ZodCheckXIDParams, $ZodChecks, $ZodCodec, $ZodCodecDef, $ZodCodecInternals, $ZodConfig, $ZodCustom, $ZodCustomDef, $ZodCustomInternals, $ZodCustomParams, $ZodCustomStringFormat, $ZodCustomStringFormatDef, $ZodCustomStringFormatInternals, $ZodDate, $ZodDateDef, $ZodDateInternals, $ZodDateParams, $ZodDefault, $ZodDefaultDef, $ZodDefaultInternals, $ZodDefaultParams, $ZodDiscriminatedUnion, $ZodDiscriminatedUnionDef, $ZodDiscriminatedUnionInternals, $ZodDiscriminatedUnionParams, $ZodE164, $ZodE164Def, $ZodE164Internals, $ZodE164Params, $ZodEmail, $ZodEmailDef, $ZodEmailInternals, $ZodEmailParams, $ZodEmoji, $ZodEmojiDef, $ZodEmojiInternals, $ZodEmojiParams, $ZodEncodeError, $ZodEnum, $ZodEnumDef, $ZodEnumInternals, $ZodEnumParams, $ZodError, $ZodErrorClass, $ZodErrorMap, $ZodErrorTree, $ZodExactOptional, $ZodExactOptionalDef, $ZodExactOptionalInternals, $ZodFile, $ZodFileDef, $ZodFileInternals, $ZodFileParams, $ZodFlattenedError, $ZodFormattedError, $ZodFunction, $ZodFunctionArgs, $ZodFunctionDef, $ZodFunctionIn, $ZodFunctionInternals, $ZodFunctionOut, $ZodFunctionParams, $ZodGUID, $ZodGUIDDef, $ZodGUIDInternals, $ZodGUIDParams, $ZodIPv4, $ZodIPv4Def, $ZodIPv4Internals, $ZodIPv4Params, $ZodIPv6, $ZodIPv6Def, $ZodIPv6Internals, $ZodIPv6Params, $ZodISODate, $ZodISODateDef, $ZodISODateInternals, $ZodISODateParams, $ZodISODateTime, $ZodISODateTimeDef, $ZodISODateTimeInternals, $ZodISODateTimeParams, $ZodISODuration, $ZodISODurationDef, $ZodISODurationInternals, $ZodISODurationParams, $ZodISOTime, $ZodISOTimeDef, $ZodISOTimeInternals, $ZodISOTimeParams, $ZodInternalIssue, $ZodIntersection, $ZodIntersectionDef, $ZodIntersectionInternals, $ZodIntersectionParams, $ZodInvalidTypeExpected, $ZodIssue, $ZodIssueBase, $ZodIssueCode, $ZodIssueCustom, $ZodIssueInvalidElement, $ZodIssueInvalidKey, $ZodIssueInvalidStringFormat, $ZodIssueInvalidType, $ZodIssueInvalidUnion, $ZodIssueInvalidValue, $ZodIssueNotMultipleOf, $ZodIssueStringCommonFormats, $ZodIssueStringEndsWith, $ZodIssueStringIncludes, $ZodIssueStringInvalidJWT, $ZodIssueStringInvalidRegex, $ZodIssueStringStartsWith, $ZodIssueTooBig, $ZodIssueTooSmall, $ZodIssueUnrecognizedKeys, $ZodJWT, $ZodJWTDef, $ZodJWTInternals, $ZodJWTParams, $ZodKSUID, $ZodKSUIDDef, $ZodKSUIDInternals, $ZodKSUIDParams, $ZodLazy, $ZodLazyDef, $ZodLazyInternals, $ZodLazyParams, $ZodLiteral, $ZodLiteralDef, $ZodLiteralInternals, $ZodLiteralParams, $ZodLooseShape, $ZodMAC, $ZodMACDef, $ZodMACInternals, $ZodMACParams, $ZodMap, $ZodMapDef, $ZodMapInternals, $ZodMapParams, $ZodNaN, $ZodNaNDef, $ZodNaNInternals, $ZodNaNParams, $ZodNanoID, $ZodNanoIDDef, $ZodNanoIDInternals, $ZodNanoIDParams, $ZodNarrow, $ZodNever, $ZodNeverDef, $ZodNeverInternals, $ZodNeverParams, $ZodNonOptional, $ZodNonOptionalDef, $ZodNonOptionalInternals, $ZodNonOptionalParams, $ZodNull, $ZodNullDef, $ZodNullInternals, $ZodNullParams, $ZodNullable, $ZodNullableDef, $ZodNullableInternals, $ZodNullableParams, $ZodNumber, $ZodNumberDef, $ZodNumberFormat, $ZodNumberFormatDef, $ZodNumberFormatInternals, $ZodNumberFormatParams, $ZodNumberFormats, $ZodNumberInternals, $ZodNumberParams, $ZodObject, $ZodObjectConfig, $ZodObjectDef, $ZodObjectInternals, $ZodObjectJIT, $ZodObjectParams, $ZodOptional, $ZodOptionalDef, $ZodOptionalInternals, $ZodOptionalParams, $ZodPipe, $ZodPipeDef, $ZodPipeInternals, $ZodPipeParams, $ZodPrefault, $ZodPrefaultDef, $ZodPrefaultInternals, $ZodPromise, $ZodPromiseDef, $ZodPromiseInternals, $ZodPromiseParams, $ZodRawIssue, $ZodReadonly, $ZodReadonlyDef, $ZodReadonlyInternals, $ZodReadonlyParams, $ZodRealError$1 as $ZodRealError, $ZodRecord, $ZodRecordDef, $ZodRecordInternals, $ZodRecordKey, $ZodRecordParams, $ZodRegistry, $ZodSet, $ZodSetDef, $ZodSetInternals, $ZodSetParams, $ZodShape, $ZodStandardSchema, $ZodString, $ZodStringBoolParams, $ZodStringDef, $ZodStringFormat, $ZodStringFormatChecks, $ZodStringFormatDef, $ZodStringFormatInternals, $ZodStringFormatIssues, $ZodStringFormatParams, $ZodStringFormatTypes, $ZodStringFormats, $ZodStringInternals, $ZodStringParams, $ZodSuccess, $ZodSuccessDef, $ZodSuccessInternals, $ZodSuccessParams, $ZodSuperRefineIssue, $ZodSymbol, $ZodSymbolDef, $ZodSymbolInternals, $ZodSymbolParams, $ZodTemplateLiteral, $ZodTemplateLiteralDef, $ZodTemplateLiteralInternals, $ZodTemplateLiteralParams, $ZodTemplateLiteralPart, $ZodTransform, $ZodTransformDef, $ZodTransformInternals, $ZodTransformParams, $ZodTuple, $ZodTupleDef, $ZodTupleInternals, $ZodTupleParams, $ZodType, $ZodTypeDef, $ZodTypeDiscriminable, $ZodTypeDiscriminableInternals, $ZodTypeInternals, $ZodTypes, $ZodULID, $ZodULIDDef, $ZodULIDInternals, $ZodULIDParams, $ZodURL, $ZodURLDef, $ZodURLInternals, $ZodURLParams, $ZodUUID, $ZodUUIDDef, $ZodUUIDInternals, $ZodUUIDParams, $ZodUUIDv4Params, $ZodUUIDv6Params, $ZodUUIDv7Params, $ZodUndefined, $ZodUndefinedDef, $ZodUndefinedInternals, $ZodUndefinedParams, $ZodUnion, $ZodUnionDef, $ZodUnionInternals, $ZodUnionParams, $ZodUnknown, $ZodUnknownDef, $ZodUnknownInternals, $ZodUnknownParams, $ZodVoid, $ZodVoidDef, $ZodVoidInternals, $ZodVoidParams, $ZodXID, $ZodXIDDef, $ZodXIDInternals, $ZodXIDParams, $ZodXor, $ZodXorInternals, $ZodXorParams, $brand, $catchall, $constructor, $input, $loose, $output, $partial, $replace, $strict, $strip, CheckFn, CheckParams, CheckStringFormatParams, CheckTypeParams, ConcatenateTupleOfStrings, ConvertPartsToStringTuple, Doc, File$1 as File, GlobalMeta, JSONSchema$1 as JSONSchema, JSONSchemaGenerator, JSONSchemaGeneratorParams, JSONSchemaMeta, NEVER, Params, ParseContext, ParseContextInternal, ParsePayload, ProcessParams, Processor, RegistryToJSONSchemaParams, Seen, SomeType, StringFormatParams, TimePrecision, ToJSONSchemaContext, ToJSONSchemaParams, ToTemplateLiteral, TypeParams, ZodStandardJSONSchemaPayload, ZodStandardSchemaWithJSON, _$ZodType, _$ZodTypeInternals, _any, _array, _base64, _base64url, _bigint, _boolean, _catch, _check, _cidrv4, _cidrv6, _coercedBigint, _coercedBoolean, _coercedDate, _coercedNumber, _coercedString, _cuid, _cuid2, _custom, _date, _decode, _decodeAsync, _default$49 as _default, _discriminatedUnion, _e164, _email, _emoji, _encode, _encodeAsync, _endsWith, _enum, _file, _float32, _float64, _gt, _gte, _gte as _min, _guid, _includes, _int, _int32, _int64, _intersection, _ipv4, _ipv6, _isoDate, _isoDateTime, _isoDuration, _isoTime, _jwt, _ksuid, _lazy, _length, _literal, _lowercase, _lt, _lte, _lte as _max, _mac, _map, _maxLength, _maxSize, _mime, _minLength, _minSize, _multipleOf, _nan, _nanoid, _nativeEnum, _negative, _never, _nonnegative, _nonoptional, _nonpositive, _normalize, _null$1 as _null, _nullable, _number, _optional, _overwrite, _parse, _parseAsync, _pipe, _positive, _promise, _property, _readonly, _record, _refine, _regex, _safeDecode, _safeDecodeAsync, _safeEncode, _safeEncodeAsync, _safeParse, _safeParseAsync, _set, _size, _slugify, _startsWith, _string, _stringFormat, _stringbool, _success, _superRefine, _symbol, _templateLiteral, _toLowerCase, _toUpperCase, _transform, _trim, _tuple, _uint32, _uint64, _ulid, _undefined$1 as _undefined, _union, _unknown, _uppercase, _url, _uuid, _uuidv4, _uuidv6, _uuidv7, _void, _xid, _xor, clone, config, createStandardJSONSchemaMethod, createToJSONSchemaMethod, decode, decodeAsync, describe, encode, encodeAsync, extractDefs, finalize, flattenError, formatError, globalConfig, globalRegistry, initializeContext, input, isValidBase64, isValidBase64URL, isValidJWT, locales, meta, output, output as infer, parse, parseAsync, prettifyError, process$1 as process, regexes, registry, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, toDotPath, toJSONSchema, treeifyError, util, version };
}
declare namespace iso {
	export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, date$2 as date, datetime$1 as datetime, duration$1 as duration, time$1 as time };
}
declare namespace z {
	export { $RefinementCtx as RefinementCtx, $ZodErrorMap as ZodErrorMap, $ZodFlattenedError as ZodFlattenedError, $ZodFormattedError as ZodFormattedError, $ZodTypes as ZodFirstPartySchemaTypes, $brand, $input, $output, BRAND, GlobalMeta, IssueData, NEVER, SafeExtendShape, TimePrecision, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCoercedBigInt, ZodCoercedBoolean, ZodCoercedDate, ZodCoercedNumber, ZodCoercedString, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodError, ZodExactOptional, ZodFile, ZodFirstPartyTypeKind, ZodFloat32, ZodFloat64, ZodFunction, ZodGUID, ZodIPv4, ZodIPv6, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, ZodInt, ZodInt32, ZodIntersection, ZodIssue, ZodIssueCode, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMAC, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPromise, ZodRawShape, ZodReadonly, ZodRealError, ZodRecord, ZodSafeParseError, ZodSafeParseResult, ZodSafeParseSuccess, ZodSet, ZodStandardSchemaWithJSON$1 as ZodStandardSchemaWithJSON, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodType as Schema, ZodType as ZodSchema, ZodType as ZodTypeAny, ZodUInt32, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, ZodXor, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _catch$1 as catch, _default$50 as _default, _endsWith as endsWith, _enum$1 as enum, _function, _function as function, _gt as gt, _gte as gte, _includes as includes, _instanceof as instanceof, _length as length, _lowercase as lowercase, _lt as lt, _lte as lte, _maxLength as maxLength, _maxSize as maxSize, _mime as mime, _minLength as minLength, _minSize as minSize, _multipleOf as multipleOf, _negative as negative, _nonnegative as nonnegative, _nonpositive as nonpositive, _normalize as normalize, _null$2 as null, _overwrite as overwrite, _positive as positive, _property as property, _regex as regex, _size as size, _slugify as slugify, _startsWith as startsWith, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _trim as trim, _undefined$2 as undefined, _uppercase as uppercase, _void$1 as void, any, array, base64$1 as base64, base64url$1 as base64url, bigint$1 as bigint, boolean$1 as boolean, check, cidrv4$1 as cidrv4, cidrv6$1 as cidrv6, clone, codec, coerce, config, core, cuid$1 as cuid, cuid2$1 as cuid2, custom, date$1 as date, decode$1 as decode, decodeAsync$1 as decodeAsync, describe$1 as describe, discriminatedUnion, e164$1 as e164, email$1 as email, emoji$1 as emoji, encode$1 as encode, encodeAsync$1 as encodeAsync, exactOptional, file, flattenError, float32, float64, formatError, fromJSONSchema, getErrorMap, globalRegistry, guid$1 as guid, hash, hex$1 as hex, hostname$1 as hostname, httpUrl, inferFlattenedErrors, inferFormattedError, input, int, int32, int64, intersection, ipv4$1 as ipv4, ipv6$1 as ipv6, iso, json, jwt, keyof, ksuid$1 as ksuid, lazy, literal, locales, looseObject, looseRecord, mac$1 as mac, map, meta$1 as meta, nan, nanoid$1 as nanoid, nativeEnum, never, nonoptional, nullable, nullish$1 as nullish, number$1 as number, object, optional, output, output as Infer, output as TypeOf, output as infer, parse$1 as parse, parseAsync$1 as parseAsync, partialRecord, pipe, prefault, preprocess, prettifyError, promise, readonly, record, refine, regexes, registry, safeDecode$1 as safeDecode, safeDecodeAsync$1 as safeDecodeAsync, safeEncode$1 as safeEncode, safeEncodeAsync$1 as safeEncodeAsync, safeParse$1 as safeParse, safeParseAsync$1 as safeParseAsync, set, setErrorMap, strictObject, string$1 as string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, toJSONSchema, transform, treeifyError, tuple, uint32, uint64, ulid$1 as ulid, union, unknown, url, util, uuid$1 as uuid, uuidv4, uuidv6, uuidv7, xid$1 as xid, xor };
}

export {
	ChatConfig$1 as ChatConfig,
	LiipgptListeners$1 as LiipgptListeners,
	SearchResult$1 as SearchResult,
	Theme$1 as Theme,
	Translations$1 as Translations,
	TranslationsPartial$1 as TranslationsPartial,
};

export {};