@mappedin/events 6.13.0-beta.0 → 6.14.0-beta.0

package/lib/esm/index.d.ts

@@ -530,6 +530,12 @@ type TGetMapDataSharedOptions = {
 type TGetMapDataWithCredentialsOptions = {
 	/**
 	 * Mappedin auth key.
+	 *
+	 * Keys starting with `"mik_"` use the Maker data model
+	 * (`LocationProfile`, `LocationCategory`).
+	 * All other keys use the CMS/Enterprise data model
+	 * (`EnterpriseLocation`, `EnterpriseCategory`).
+	 * Using the wrong data types for your key type will return empty results.
 	 */
 	key: string;
 	/**
@@ -575,31 +581,143 @@ declare function createEnvControl(): {
 	__getState: () => Environment;
 };
 type EnvControl = ReturnType<typeof createEnvControl>;
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-	/** The Standard Schema properties. */
-	readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
+type _JSONSchema = boolean | JSONSchema;
+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;
+};
+type BaseSchema = JSONSchema;
+interface ObjectSchema extends JSONSchema {
+	type: "object";
 }
-declare namespace StandardSchemaV1 {
-	/** The Standard Schema properties interface. */
+interface ArraySchema extends JSONSchema {
+	type: "array";
+}
+interface StringSchema extends JSONSchema {
+	type: "string";
+}
+interface NumberSchema extends JSONSchema {
+	type: "number";
+}
+interface IntegerSchema extends JSONSchema {
+	type: "integer";
+}
+interface BooleanSchema extends JSONSchema {
+	type: "boolean";
+}
+interface NullSchema extends JSONSchema {
+	type: "null";
+}
+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;
-		/** Validates unknown input values. */
-		readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
 		/** Inferred types associated with the schema. */
 		readonly types?: Types<Input, Output> | undefined;
 	}
+	/** The 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"];
+}
+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 non-existent issues. */
+		/** 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. */
@@ -617,18 +735,187 @@ declare namespace StandardSchemaV1 {
 		/** The key representing a path segment. */
 		readonly key: PropertyKey;
 	}
-	/** The Standard Schema types interface. */
-	interface Types<Input = unknown, Output = Input> {
-		/** The input type of the schema. */
-		readonly input: Input;
-		/** The output type of the schema. */
-		readonly output: Output;
+	/** 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>;
+}
+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 Schema. */
-	type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-	/** Infers the output type of a Standard Schema. */
-	type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+	/** 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>;
 }
+interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
+}
+declare const $output: unique symbol;
+type $output = typeof $output;
+declare const $input: unique symbol;
+type $input = typeof $input;
+type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
+	[K in keyof P]: $replace<P[K], S>;
+}) => $replace<R, S> : Meta extends object ? {
+	[K in keyof Meta]: $replace<Meta[K], S>;
+} : Meta;
+type MetadataType = 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;
+}
+interface JSONSchemaMeta {
+	id?: string | undefined;
+	title?: string | undefined;
+	description?: string | undefined;
+	deprecated?: boolean | undefined;
+	[k: string]: unknown;
+}
+interface GlobalMeta extends JSONSchemaMeta {
+}
+declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
+declare const globalRegistry: $ZodRegistry<GlobalMeta>;
+type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: JSONSchema$1.BaseSchema, params: ProcessParams) => void;
+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;
+}
+type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
+interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
+	uri?: (id: string) => string;
+}
+interface ProcessParams {
+	schemaPath: schemas.$ZodType[];
+	path: (string | number)[];
+}
+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;
+}
+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>;
+type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
+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>;
+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;
 type JSONType = string | number | boolean | null | JSONType[] | {
 	[key: string]: JSONType;
 };
@@ -770,6 +1057,7 @@ declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
 }>;
 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: {
@@ -826,6 +1114,7 @@ declare function unwrapMessage(message: string | {
 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[];
@@ -840,7 +1129,7 @@ declare abstract class Class {
 }
 declare const version: {
 	readonly major: 4;
-	readonly minor: 1;
+	readonly minor: 3;
 	readonly patch: number;
 };
 interface ParseContext<T extends $ZodIssueBase = never> {
@@ -907,6 +1196,8 @@ interface _$ZodTypeInternals {
 	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. */
@@ -1112,6 +1403,16 @@ interface $ZodIPv6 extends $ZodType {
 	_zod: $ZodIPv6Internals;
 }
 declare const $ZodIPv6: $constructor<$ZodIPv6>;
+interface $ZodMACDef extends $ZodStringFormatDef<"mac"> {
+	delimiter?: string;
+}
+interface $ZodMACInternals extends $ZodStringFormatInternals<"mac"> {
+	def: $ZodMACDef;
+}
+interface $ZodMAC extends $ZodType {
+	_zod: $ZodMACInternals;
+}
+declare const $ZodMAC: $constructor<$ZodMAC>;
 interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
 	version?: "v4";
 }
@@ -1434,7 +1735,6 @@ type $ZodLooseShape = Record<string, any>;
 interface $ZodObject<
 /** @ts-ignore Cast variance */
 out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
-	"~standard": $ZodStandardSchema<this>;
 }
 declare const $ZodObject: $constructor<$ZodObject>;
 declare const $ZodObjectJIT: $constructor<$ZodObject>;
@@ -1443,6 +1743,7 @@ type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
 interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
 	type: "union";
 	options: Options;
+	inclusive?: boolean;
 }
 type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
 type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
@@ -1460,6 +1761,12 @@ interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends
 	_zod: $ZodUnionInternals<T>;
 }
 declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodXorInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<T> {
+}
+interface $ZodXor<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodXorInternals<T>> {
+	_zod: $ZodXorInternals<T>;
+}
+declare const $ZodXor: $constructor<$ZodXor>;
 interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
 	discriminator: Disc;
 	unionFallback?: boolean;
@@ -1536,14 +1843,16 @@ interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extend
 	_zod: $ZodTupleInternals<T, Rest>;
 }
 declare const $ZodTuple: $constructor<$ZodTuple>;
-type $ZodRecordKey = $ZodType<string | number | symbol, string | number | symbol>;
+type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
 interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
 	type: "record";
 	keyType: Key;
 	valueType: Value;
+	/** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+	mode?: "strict" | "loose";
 }
 type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
-type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key>, input<Value>>> : Record<input<Key>, input<Value>>;
+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>>;
 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>>;
@@ -1671,6 +1980,17 @@ interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
 	_zod: $ZodOptionalInternals<T>;
 }
 declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {
+}
+interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
+	def: $ZodExactOptionalDef<T>;
+	output: output<T>;
+	input: input<T>;
+}
+interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
+	_zod: $ZodExactOptionalInternals<T>;
+}
+declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
 interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
 	type: "nullable";
 	innerType: T;
@@ -1881,7 +2201,7 @@ type $ZodFunctionOut = $ZodType;
 type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
 type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => util.MaybeAsync<input<Returns>>;
 type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
-type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => util.MaybeAsync<output<Returns>>;
+type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => Promise<output<Returns>>;
 interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
 	type: "function";
 	input: In;
@@ -1912,7 +2232,7 @@ interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
 	type: "promise";
 	innerType: T;
 }
-interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, util.MaybeAsync<input<T>>> {
+interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T>>, util.MaybeAsync<input<T>>> {
 	def: $ZodPromiseDef<T>;
 	isst: never;
 }
@@ -1959,7 +2279,7 @@ interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
 }
 declare const $ZodCustom: $constructor<$ZodCustom>;
 type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
-type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname">;
+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">;
 interface $ZodCheckDef {
 	check: string;
 	error?: $ZodErrorMap<never> | undefined;
@@ -2240,9 +2560,10 @@ interface $ZodIssueBase {
 	readonly path: PropertyKey[];
 	readonly message: string;
 }
+type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
 interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
 	readonly code: "invalid_type";
-	readonly expected: $ZodType["_zod"]["def"]["type"];
+	readonly expected: $ZodInvalidTypeExpected;
 	readonly input?: Input;
 }
 interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
@@ -2279,12 +2600,22 @@ interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
 	readonly keys: string[];
 	readonly input?: Record<string, unknown>;
 }
-interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
 	readonly code: "invalid_union";
 	readonly errors: $ZodIssue[][];
 	readonly input?: unknown;
 	readonly discriminator?: string | undefined;
+	readonly inclusive?: true;
 }
+interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
+	readonly code: "invalid_union";
+	readonly errors: [
+	];
+	readonly input?: unknown;
+	readonly discriminator?: string | undefined;
+	readonly inclusive: false;
+}
+type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
 interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
 	readonly code: "invalid_key";
 	readonly origin: "map" | "record";
@@ -2432,7 +2763,25 @@ type $brand<T extends string | number | symbol = string | number | symbol> = {
 		[k in T]: true;
 	};
 };
-type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
+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>;
+	};
+});
+type $ZodNarrow<T extends schemas.SomeType, Out> = T & {
+	_zod: {
+		output: Out;
+	};
+};
 declare class $ZodAsyncError extends Error {
 	constructor();
 }
@@ -2526,6 +2875,7 @@ 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;
@@ -2698,55 +3048,25 @@ declare function _default$41(): {
 };
 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 const $output: unique symbol;
-type $output = typeof $output;
-declare const $input: unique symbol;
-type $input = typeof $input;
-type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
-	[K in keyof P]: $replace<P[K], S>;
-}) => $replace<R, S> : Meta extends object ? {
-	[K in keyof Meta]: $replace<Meta[K], S>;
-} : Meta;
-type MetadataType = 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;
-}
-interface JSONSchemaMeta {
-	id?: string | undefined;
-	title?: string | undefined;
-	description?: string | undefined;
-	deprecated?: boolean | undefined;
-	[k: string]: unknown;
-}
-interface GlobalMeta extends JSONSchemaMeta {
-}
-declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
-declare const globalRegistry: $ZodRegistry<GlobalMeta>;
+};
+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;
+};
 type ModeWriter = (doc: Doc, modes: {
 	execution: "sync" | "async";
 }) => void;
@@ -2830,6 +3150,9 @@ declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, p
 type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
 type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
 declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
+type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
+type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
+declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;
 type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
 type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
 declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
@@ -2953,11 +3276,14 @@ declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {
 declare function _trim(): $ZodCheckOverwrite<string>;
 declare function _toLowerCase(): $ZodCheckOverwrite<string>;
 declare function _toUpperCase(): $ZodCheckOverwrite<string>;
+declare function _slugify(): $ZodCheckOverwrite<string>;
 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>;
 type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchall">;
 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>;
+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>;
 interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
 	propValues: util.PropValues;
 }
@@ -3002,7 +3328,7 @@ declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass
 type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
 declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;
 type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
-declare function _default$47<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<output<T>> | (() => util.NoUndefined<output<T>>)): schemas.$ZodDefault<T>;
+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>;
 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>;
 type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
@@ -3034,6 +3360,8 @@ interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
 }
 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>;
 interface $ZodStringBoolParams extends TypeParams {
 	truthy?: string[];
 	falsy?: string[];
@@ -3050,180 +3378,47 @@ declare function _stringbool(Classes: {
 	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>;
-type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
-type _JSONSchema = boolean | JSONSchema;
-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;
+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>>;
 };
-type BaseSchema = JSONSchema;
-interface ObjectSchema extends JSONSchema {
-	type: "object";
-}
-interface ArraySchema extends JSONSchema {
-	type: "array";
-}
-interface StringSchema extends JSONSchema {
-	type: "string";
-}
-interface NumberSchema extends JSONSchema {
-	type: "number";
-}
-interface IntegerSchema extends JSONSchema {
-	type: "integer";
-}
-interface BooleanSchema extends JSONSchema {
-	type: "boolean";
-}
-interface NullSchema extends JSONSchema {
-	type: "null";
-}
-interface JSONSchemaGeneratorParams {
-	/** 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-7"` — JSON Schema Draft 7
-	 * - `"draft-4"` — JSON Schema Draft 4
-	 * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
-	target?: "draft-4" | "draft-7" | "draft-2020-12" | "openapi-3.0";
-	/** 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, Error converting schema to JSONz, defaults, coerced primitives, etc.
-	 * - `"output"` — Default. Convert the output schema.
-	 * - `"input"` — Convert the input schema. */
-	io?: "input" | "output";
-}
-interface ProcessParams {
-	schemaPath: schemas.$ZodType[];
-	path: (string | number)[];
-}
-interface EmitParams {
-	/** How to handle cycles.
-	 * - `"ref"` — Default. Cycles will be broken using $defs
-	 * - `"throw"` — Cycles will throw an error if encountered */
-	cycles?: "ref" | "throw";
-	reused?: "ref" | "inline";
-	external?: {
-		/**  */
-		registry: $ZodRegistry<{
-			id?: string | undefined;
-		}>;
-		uri?: ((id: string) => string) | undefined;
-		defs: Record<string, JSONSchema$1.BaseSchema>;
-	} | undefined;
-}
-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;
-	ref?: schemas.$ZodType | undefined | null;
-	/** JSON Schema property path for this schema */
-	path?: (string | number)[] | undefined;
-}
+type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
+type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
 declare class JSONSchemaGenerator {
-	metadataRegistry: $ZodRegistry<Record<string, any>>;
-	target: "draft-4" | "draft-7" | "draft-2020-12" | "openapi-3.0";
-	unrepresentable: "throw" | "any";
-	override: (ctx: {
-		zodSchema: schemas.$ZodTypes;
+	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;
-	io: "input" | "output";
-	counter: number;
-	seen: Map<schemas.$ZodType, Seen>;
-	constructor(params?: JSONSchemaGeneratorParams);
+	/** @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;
 }
-interface ToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, "external"> {
-}
-interface RegistryToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, "external"> {
-	uri?: (id: string) => string;
-}
-declare function toJSONSchema(schema: schemas.$ZodType, _params?: ToJSONSchemaParams): JSONSchema$1.BaseSchema;
-declare function toJSONSchema(registry: $ZodRegistry<{
-	id?: string | undefined;
-}>, _params?: RegistryToJSONSchemaParams): {
-	schemas: Record<string, JSONSchema$1.BaseSchema>;
-};
 type ZodIssue = core.$ZodIssue;
 interface ZodError<T = unknown> extends $ZodError<T> {
 	/** @deprecated Use the `z.treeifyError(err)` function instead. */
@@ -3271,6 +3466,7 @@ declare const safeEncode$1: <T extends core.$ZodType>(schema: T, value: core.out
 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>>;
 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"];
@@ -3280,7 +3476,11 @@ interface ZodType<out Output = unknown, out Input = unknown, out Internals exten
 	_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;
@@ -3291,7 +3491,7 @@ interface ZodType<out Output = unknown, out Input = unknown, out Internals exten
 	] : [
 		"Incompatible schema"
 	]): this;
-	brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : core.$ZodBranded<this, T>;
+	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>>;
@@ -3305,10 +3505,11 @@ interface ZodType<out Output = unknown, out Input = unknown, out Internals exten
 	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(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): 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>>;
@@ -3351,6 +3552,7 @@ interface ZodType<out Output = unknown, out Input = unknown, out Internals exten
 	 * ```
 	 */
 	isNullable(): boolean;
+	apply<T>(fn: (schema: this) => T): T;
 }
 interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodType<any, any, Internals> {
 }
@@ -3360,7 +3562,7 @@ interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStri
 	minLength: number | null;
 	maxLength: number | null;
 	regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;
-	includes(value: string, params?: core.$ZodCheckIncludesParams): 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;
@@ -3373,6 +3575,7 @@ interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStri
 	normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
 	toLowerCase(): this;
 	toUpperCase(): this;
+	slugify(): this;
 }
 declare const _ZodString: core.$constructor<_ZodString>;
 interface ZodString extends _ZodString<core.$ZodStringInternals<string>> {
@@ -3501,6 +3704,11 @@ interface ZodIPv4 extends ZodStringFormat<"ipv4"> {
 }
 declare const ZodIPv4: core.$constructor<ZodIPv4>;
 declare function ipv4$1(params?: string | core.$ZodIPv4Params): ZodIPv4;
+interface ZodMAC extends ZodStringFormat<"mac"> {
+	_zod: core.$ZodMACInternals;
+}
+declare const ZodMAC: core.$constructor<ZodMAC>;
+declare function mac$1(params?: string | core.$ZodMACParams): ZodMAC;
 interface ZodIPv6 extends ZodStringFormat<"ipv6"> {
 	_zod: core.$ZodIPv6Internals;
 }
@@ -3538,6 +3746,7 @@ declare const ZodJWT: core.$constructor<ZodJWT>;
 declare function jwt(params?: string | core.$ZodJWTParams): ZodJWT;
 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>;
@@ -3680,6 +3889,7 @@ interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodType<cor
 	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>;
@@ -3690,6 +3900,7 @@ type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShap
 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. */
@@ -3708,18 +3919,18 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
 	 * @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): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
-	omit<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, 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): ZodObject<{
+	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): ZodObject<{
+	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>;
 }
@@ -3728,11 +3939,19 @@ declare function object<T extends core.$ZodLooseShape = Partial<Record<never, co
 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>;
 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>;
+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>;
 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>;
 }
@@ -3742,10 +3961,12 @@ declare function discriminatedUnion<Types extends readonly [
 	...core.$ZodTypeDiscriminable[]
 ], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
 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>;
 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>;
@@ -3761,19 +3982,27 @@ declare function tuple(items: [
 ], params?: string | core.$ZodTupleParams): ZodTuple<[
 ], null>;
 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>;
 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>;
 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;
@@ -3784,6 +4013,7 @@ declare function set<Value extends core.SomeType>(valueType: Value, params?: str
 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]>>>;
@@ -3794,6 +4024,7 @@ declare function _enum$1<const T extends readonly string[]>(values: T, params?:
 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>;
 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;
@@ -3802,6 +4033,7 @@ 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>;
 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;
@@ -3809,43 +4041,57 @@ interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile {
 declare const ZodFile: core.$constructor<ZodFile>;
 declare function file(params?: string | core.$ZodFileParams): ZodFile;
 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>;
 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>;
+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>;
 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>>;
 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$48<T extends core.SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodDefault<T>;
+declare function _default$50<T extends core.SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodDefault<T>;
 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>;
 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>;
 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>;
 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;
@@ -3853,16 +4099,19 @@ interface ZodCatch<T extends core.SomeType = core.$ZodType> extends _ZodType<cor
 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>;
 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;
 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>;
 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>;
 }
@@ -3872,25 +4121,30 @@ declare function codec<const A extends core.SomeType, B extends core.SomeType =
 	encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodCodec<A, B>;
 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>;
 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>>;
 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>;
 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>;
 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>;
@@ -3919,12 +4173,15 @@ declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunctionIn,
 	output: Out;
 }): ZodFunction<In, Out>;
 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;
 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>;
@@ -3971,6 +4228,12 @@ declare function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined;
 type ZodRawShape = core.$ZodShape;
 declare enum ZodFirstPartyTypeKind {
 }
+type JSONSchemaVersion = "draft-2020-12" | "draft-7" | "draft-4" | "openapi-3.0";
+interface FromJSONSchemaParams {
+	defaultTarget?: JSONSchemaVersion;
+	registry?: $ZodRegistry<any>;
+}
+declare function fromJSONSchema(schema: JSONSchema$1.JSONSchema | boolean, params?: FromJSONSchemaParams): ZodType;
 interface ZodISODateTime extends schemas$1.ZodStringFormat {
 	_zod: core.$ZodISODateTimeInternals;
 }
@@ -4833,7 +5096,7 @@ type LocationData = Omit<MVF2Location, "categories" | "spaces" | "obstructions"
 declare class LocationProfile extends BaseMetaData implements LocationData, IFocusable, INavigatable {
 	#private;
 	/**
-	 * Checks if the provided instance is of type EnterpriseLocation.
+	 * Checks if the provided instance is of type LocationProfile.
 	 *
 	 * @param instance The instance to check.
 	 * @returns {boolean} True if the instance is a EnterpriseLocation, false otherwise.
@@ -4945,6 +5208,9 @@ declare class LocationProfile extends BaseMetaData implements LocationData, IFoc
 	/**
 	 * Gets the {@link LocationCategory}s associated with the location.
 	 *
+	 * @remarks
+	 * **Data Source: Maker** - This property is only available when using Maker credentials.
+	 *
 	 * @returns {LocationCategory[]} The location categories array.
 	 */
 	get categories(): LocationCategory[];
@@ -5042,6 +5308,11 @@ declare abstract class DetailedMapData<MVFData extends MVFFeature<Geometry, {
 	/**
 	 * Gets the {@link LocationProfile}s attached to this feature.
 	 *
+	 * @remarks
+	 * **Data Source: Maker** - This property is only populated when using Maker credentials
+	 * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise credentials.
+	 * For Enterprise data, use {@link Space.enterpriseLocations} or {@link MapObject.enterpriseLocations} instead.
+	 *
 	 * @returns {LocationProfile[]} An array of location profiles.
 	 */
 	get locationProfiles(): LocationProfile[];
@@ -5249,6 +5520,12 @@ declare class Space extends DetailedMapData<SpaceFeature> implements IGeoJSONDat
 	/**
 	 * Gets the {@link EnterpriseLocation}s attached to this space.
 	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials
+	 * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty array when
+	 * using Maker credentials. For Maker data, access locations via {@link LocationProfile.spaces}
+	 * instead.
+	 *
 	 * @returns {EnterpriseLocation[]} An array of enterprise locations.
 	 */
 	get enterpriseLocations(): EnterpriseLocation[];
@@ -5256,6 +5533,10 @@ declare class Space extends DetailedMapData<SpaceFeature> implements IGeoJSONDat
 	 * Gets the {@link EnterpriseLocation}s attached to this space.
 	 *
 	 * @deprecated Use {@link enterpriseLocations} instead. This property will be removed in a future release.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials.
+	 *
 	 * @returns {EnterpriseLocation[]} An array of enterprise locations.
 	 */
 	get locations(): EnterpriseLocation[];
@@ -5269,6 +5550,10 @@ declare class Space extends DetailedMapData<SpaceFeature> implements IGeoJSONDat
 	/**
 	 * Gets the array of {@link Door}s associated with the space.
 	 *
+	 * @remarks
+	 * **Data Source: Maker** - This property is only populated when using Maker credentials
+	 * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise credentials.
+	 *
 	 * @returns {Door[]} The doors array.
 	 */
 	get doors(): Door[];
@@ -5629,6 +5914,12 @@ declare class MapObject extends DetailedMapData<ObstructionFeature> implements I
 	/**
 	 * Gets the {@link EnterpriseLocation}s attached to this object.
 	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials
+	 * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty array when
+	 * using Maker credentials. For Maker data, access locations via {@link LocationProfile.mapObjects}
+	 * instead.
+	 *
 	 * @returns {EnterpriseLocation[]} An array of enterprise locations.
 	 */
 	get enterpriseLocations(): EnterpriseLocation[];
@@ -5636,6 +5927,10 @@ declare class MapObject extends DetailedMapData<ObstructionFeature> implements I
 	 * Gets the {@link EnterpriseLocation}s attached to this object.
 	 *
 	 * @deprecated Use {@link enterpriseLocations} instead. This property will be removed in a future release.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials.
+	 *
 	 * @returns {EnterpriseLocation[]} An array of enterprise locations.
 	 */
 	get locations(): EnterpriseLocation[];
@@ -5903,7 +6198,16 @@ declare class Node$1 extends BaseMetaData implements IGeoJSONData, IFocusable, I
 		floorId: string;
 		mvfData: MVFNodeFeature;
 	});
-	/** @internal */
+	/**
+	 * Gets the {@link EnterpriseLocation}s attached to this node.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials
+	 * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty array when
+	 * using Maker credentials.
+	 *
+	 * @internal
+	 */
 	get locations(): EnterpriseLocation[];
 	/**
 	 * Gets the {@link Space} object associated with the node.
@@ -6362,9 +6666,17 @@ declare class EnterpriseLocation extends BaseMetaData implements Omit<MVFEnterpr
 		parentId?: string;
 	});
 	/** @internal */
-	get focusTarget(): Space[];
+	get focusTarget(): Coordinate[] | Space[];
 	/** @internal */
 	get navigationTarget(): Space[];
+	/**
+	 * Gets the {@link EnterpriseCategory}s associated with the location.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only available when using CMS/Enterprise credentials.
+	 *
+	 * @returns {EnterpriseCategory[]} The enterprise categories array.
+	 */
 	get categories(): EnterpriseCategory[];
 	get coordinates(): Coordinate[];
 	get nodes(): Node$1[];
@@ -6445,10 +6757,16 @@ declare class EnterpriseCategory extends BaseMetaData implements Omit<MVFEnterpr
 	});
 	/**
 	 * The child categories of the category.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only available when using CMS/Enterprise credentials.
 	 */
 	get children(): EnterpriseCategory[];
 	/**
 	 * The {@link EnterpriseLocation}s within this category.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - This property is only available when using CMS/Enterprise credentials.
 	 */
 	get locations(): EnterpriseLocation[];
 	/**
@@ -6585,6 +6903,7 @@ declare class EnterpriseVenue extends BaseMetaData implements MVFEnterpriseVenue
 	destroy(): void;
 }
 type TQueriables = PointOfInterest | Door | Annotation | Node$1 | Space | EnterpriseLocation;
+type TQueryAtResult = Space | MapObject | Area | Floor;
 type TFindNearestResult<T extends TQueriables> = {
 	distance: number;
 	feature: T;
@@ -6643,6 +6962,25 @@ declare class Query {
 	 * @returns Objects with the distance and the feature, sorted by distance
 	 */
 	nearest<T extends TQueriables>(origin: Coordinate | PointOfInterest | Door | Annotation | Node$1, include: T[], options?: TFindNearestOptions): Promise<TFindNearestResult<T> | undefined>;
+	/**
+	 * Find all geometry objects (Spaces, MapObjects, Areas, Floors) at the given coordinate.
+	 * If the coordinate has a floorId, only that floor is searched.
+	 * If no floorId is provided, all floors are searched.
+	 * @param coordinate - The coordinate to search at
+	 * @returns Array of Spaces, MapObjects, Areas, and Floors that contain the coordinate
+	 * @example
+	 * ```typescript
+	 * // Find all geometry at a coordinate with a floor
+	 * const coord = new Coordinate({ latitude: 43.861, longitude: -78.947, floorId: 'floor1' });
+	 * const results = await mapData.Query.at(coord);
+	 * // results may contain [Space, Floor, Area, ...]
+	 *
+	 * // Find all geometry at a coordinate across all floors
+	 * const coordNoFloor = new Coordinate({ latitude: 43.861, longitude: -78.947 });
+	 * const allResults = await mapData.Query.at(coordNoFloor);
+	 * ```
+	 */
+	at(coordinate: Coordinate): Promise<TQueryAtResult[]>;
 }
 declare class LocationCategory extends BaseMetaData implements Omit<MVFCategory, "parent"> {
 	#private;
@@ -6676,15 +7014,24 @@ declare class LocationCategory extends BaseMetaData implements Omit<MVFCategory,
 	/**
 	 * Gets the parent {@link LocationCategory}.
 	 *
+	 * @remarks
+	 * **Data Source: Maker** - This property is only available when using Maker credentials.
+	 *
 	 * @returns {LocationCategory | undefined} The parent location category.
 	 */
 	get parent(): LocationCategory | undefined;
 	/**
 	 * Gets the children {@link LocationCategory}s.
+	 *
+	 * @remarks
+	 * **Data Source: Maker** - This property is only available when using Maker credentials.
 	 */
 	get children(): LocationCategory[];
 	/**
 	 * Gets the {@link LocationProfile}s that are associated with this category.
+	 *
+	 * @remarks
+	 * **Data Source: Maker** - This property is only available when using Maker credentials.
 	 */
 	get locationProfiles(): LocationProfile[];
 	toJSON(): {
@@ -7010,6 +7357,10 @@ type THydrateMapDataBundle = {
 	type: "binary";
 	options?: {
 		version?: "2.0.0" | "3.0.0";
+		/**
+		 * @deprecated This option is no longer needed and will be removed in a future release.
+		 * Enterprise mode is now automatically detected from the MVF data.
+		 */
 		enterprise?: boolean;
 	};
 	languagePacks?: {
@@ -7024,6 +7375,10 @@ type THydrateMapDataBundle = {
 	type: "json";
 	options?: {
 		version?: "2.0.0" | "3.0.0";
+		/**
+		 * @deprecated This option is no longer needed and will be removed in a future release.
+		 * Enterprise mode is now automatically detected from the MVF data.
+		 */
 		enterprise?: boolean;
 		mvf3?: MVFv2_STANDARD_MVFv3;
 	};
@@ -7195,6 +7550,54 @@ declare class MapData {
 	 * ```
 	 */
 	get mapId(): string | undefined;
+	/**
+	 * Indicates whether the map data was loaded from a CMS/Enterprise data source.
+	 *
+	 * Use this property to determine which data types to access at runtime, especially
+	 * when loading map data from a zip file where the data source is unknown beforehand.
+	 *
+	 * @remarks
+	 * **Data Source Detection:**
+	 * - `true` - Map uses CMS/Enterprise data. Use `enterprise-location`, `enterprise-category`, `enterprise-venue`.
+	 * - `false` - Map uses Maker data. Use `location-profile`, `location-category`.
+	 *
+	 * **Important for AI/Code Generation:**
+	 * When loading from a zip file (using `hydrateMapData`), always check this property
+	 * and write code that handles both data sources dynamically. This ensures your code
+	 * works with any map regardless of its origin.
+	 *
+	 * @returns {boolean} `true` if using CMS/Enterprise data source, `false` if using Maker.
+	 *
+	 * @example Dynamic data source handling (recommended for zip files)
+	 * ```ts
+	 * import { hydrateMapData } from '@mappedin/mappedin-js';
+	 *
+	 * const mapData = await hydrateMapData(bundle);
+	 *
+	 * // Handle both data sources dynamically
+	 * const locations = mapData.isEnterpriseMode
+	 *   ? mapData.getByType('enterprise-location')
+	 *   : mapData.getByType('location-profile');
+	 *
+	 * const categories = mapData.isEnterpriseMode
+	 *   ? mapData.getByType('enterprise-category')
+	 *   : mapData.getByType('location-category');
+	 *
+	 * // Now use locations and categories regardless of data source
+	 * locations.forEach(loc => console.log(loc.name));
+	 * ```
+	 *
+	 * @example Conditional logic based on data source
+	 * ```ts
+	 * if (mapData.isEnterpriseMode) {
+	 *   const venue = mapData.getByType('enterprise-venue');
+	 *   console.log('Enterprise venue:', venue?.name);
+	 * } else {
+	 *   console.log('Maker map - no venue object available');
+	 * }
+	 * ```
+	 */
+	get isEnterpriseMode(): boolean;
 	/**
 	 * The approximate center coordinate ({@link Coordinate}) of the map.
 	 *
@@ -7357,6 +7760,12 @@ declare class MapData {
 	getByType(type: "area"): Area[];
 	/**
 	 * @returns The enterprise locations ({@link EnterpriseLocation}) on the map.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - Only populated when using CMS/Enterprise credentials
+	 * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty
+	 * array when using Maker credentials. Use `'location-profile'` instead for Maker data.
+	 *
 	 * @example
 	 * ```ts
 	 * const locations = mapData.getByType('enterprise-location');
@@ -7366,6 +7775,12 @@ declare class MapData {
 	getByType(type: "enterprise-location"): EnterpriseLocation[];
 	/**
 	 * @returns The enterprise categories ({@link EnterpriseCategory}) on the map.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - Only populated when using CMS/Enterprise credentials
+	 * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty
+	 * array when using Maker credentials. Use `'location-category'` instead for Maker data.
+	 *
 	 * @example
 	 * ```ts
 	 * const categories = mapData.getByType('enterprise-category');
@@ -7374,16 +7789,30 @@ declare class MapData {
 	 */
 	getByType(type: "enterprise-category"): EnterpriseCategory[];
 	/**
-	 * @returns The enterprise venues ({@link EnterpriseVenue}) on the map.
+	 * @returns The enterprise venue ({@link EnterpriseVenue}) for the map, or undefined if not available.
+	 *
+	 * @remarks
+	 * **Data Source: Enterprise** - Only available when using CMS/Enterprise credentials
+	 * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns undefined
+	 * when using Maker credentials.
+	 *
 	 * @example
 	 * ```ts
-	 * const venues = mapData.getByType('enterprise-venue');
-	 * const malls = venues.filter(venue => venue.type === 'mall');
+	 * const venue = mapData.getByType('enterprise-venue');
+	 * if (venue) {
+	 *   console.log(venue.name, venue.languages);
+	 * }
 	 * ```
 	 */
 	getByType(type: "enterprise-venue"): EnterpriseVenue | undefined;
 	/**
 	 * @returns The location profiles ({@link LocationProfile}) on the map.
+	 *
+	 * @remarks
+	 * **Data Source: Maker** - Only populated when using Maker credentials
+	 * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise
+	 * credentials. Use `'enterprise-location'` instead for Enterprise data.
+	 *
 	 * @example
 	 * ```ts
 	 * const profiles = mapData.getByType('location-profile');
@@ -7393,6 +7822,12 @@ declare class MapData {
 	getByType(type: "location-profile"): LocationProfile[];
 	/**
 	 * @returns The location categories ({@link LocationCategory}) on the map.
+	 *
+	 * @remarks
+	 * **Data Source: Maker** - Only populated when using Maker credentials
+	 * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise
+	 * credentials. Use `'enterprise-category'` instead for Enterprise data.
+	 *
 	 * @example
 	 * ```ts
 	 * const categories = mapData.getByType('location-category');
@@ -7405,6 +7840,12 @@ declare class MapData {
 	 *
 	 * Use this method to find individual map elements when you know their exact ID. This is more efficient than filtering collections for specific elements.
 	 *
+	 * @remarks
+	 * **Data Source Availability:**
+	 * - `'enterprise-location'`, `'enterprise-category'`, `'enterprise-venue'` - Only available with CMS/Enterprise credentials
+	 * - `'location-profile'`, `'location-category'` - Only available with Maker credentials (keys starting with `mik_`)
+	 * - All other types (`'space'`, `'floor'`, `'door'`, etc.) - Available with both credential types
+	 *
 	 * @param type The type of element to retrieve.
 	 * @param id The unique identifier of the element.
 	 * @returns The map element if found, undefined otherwise.
@@ -7453,6 +7894,12 @@ declare class MapData {
 	 *
 	 * External IDs are custom identifiers that can be assigned to map elements. This is useful for integrating with external systems or databases.
 	 *
+	 * @remarks
+	 * **Data Source Availability:**
+	 * - `'enterprise-location'`, `'enterprise-category'` - Only available with CMS/Enterprise credentials
+	 * - `'location-profile'` - Only available with Maker credentials (keys starting with `mik_`)
+	 * - All other types (`'space'`, `'floor'`, etc.) - Available with both credential types
+	 *
 	 * @param type The type of element to retrieve.
 	 * @param externalId The external identifier to search for.
 	 * @returns An array of elements with the matching external ID.
@@ -7463,11 +7910,19 @@ declare class MapData {
 	 * spaces.forEach(space => console.log(`Found space: ${space.name}`));
 	 * ```
 	 *
-	 * @example Find locations by external ID
+	 * @example Find locations by external ID (Enterprise)
 	 * ```ts
+	 * // With CMS/Enterprise credentials:
 	 * const locations = mapData.getByExternalId('enterprise-location', 'RESTAURANT-ABC');
 	 * locations.forEach(location => console.log(`Found location: ${location.name}`));
 	 * ```
+	 *
+	 * @example Find locations by external ID (Maker)
+	 * ```ts
+	 * // With Maker credentials (mik_ keys):
+	 * const locations = mapData.getByExternalId('location-profile', 'RESTAURANT-ABC');
+	 * locations.forEach(location => console.log(`Found location: ${location.name}`));
+	 * ```
 	 */
 	getByExternalId<T extends keyof Omit<TMapDataObjectTypes, "annotation" | "facade">>(type: T, externalId: string): TMapDataObjectTypes[T][];
 	/**
@@ -7863,35 +8318,35 @@ export declare class EventsManager {
 	destroy(): void;
 }
 
+declare namespace JSONSchema$1 {
+	export { ArraySchema, BaseSchema, BooleanSchema, IntegerSchema, JSONSchema, NullSchema, NumberSchema, ObjectSchema, Schema, StringSchema, _JSONSchema };
+}
 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, $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, $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, $catchall, $loose, $partial, $strict, $strip, CheckFn, ConcatenateTupleOfStrings, ConvertPartsToStringTuple, File$1 as File, ParseContext, ParseContextInternal, ParsePayload, SomeType, ToTemplateLiteral, _$ZodType, _$ZodTypeInternals, clone, isValidBase64, isValidBase64URL, isValidJWT };
+	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 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, partial, pick, prefixIssues, primitiveTypes, promiseAllObject, propertyKeyTypes, randomString, required, safeExtend, shallowClone, stringifyPrimitive, uint8ArrayToBase64, uint8ArrayToBase64url, uint8ArrayToHex, unwrapMessage };
-}
-declare namespace JSONSchema$1 {
-	export { ArraySchema, BaseSchema, BooleanSchema, IntegerSchema, JSONSchema, NullSchema, NumberSchema, ObjectSchema, Schema, StringSchema, _JSONSchema };
+	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 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, 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 };
+	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 id, _default$18 as is, _default$19 as it, _default$2 as be, _default$20 as ja, _default$21 as ka, _default$22 as kh, _default$23 as km, _default$24 as ko, _default$25 as lt, _default$26 as mk, _default$27 as ms, _default$28 as nl, _default$29 as no, _default$3 as bg, _default$30 as ota, _default$31 as ps, _default$32 as pl, _default$33 as pt, _default$34 as ru, _default$35 as sl, _default$36 as sv, _default$37 as ta, _default$38 as th, _default$39 as tr, _default$4 as ca, _default$40 as ua, _default$41 as uk, _default$42 as ur, _default$43 as vi, _default$44 as zhCN, _default$45 as zhTW, _default$46 as yo, _default$5 as cs, _default$6 as da, _default$7 as de, _default$8 as en, _default$9 as eo };
+	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, ZodFile, ZodFloat32, ZodFloat64, ZodFunction, ZodGUID, ZodIPv4, ZodIPv6, ZodInt, ZodInt32, ZodIntersection, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPromise, ZodReadonly, ZodRecord, ZodSet, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodUInt32, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _catch$1 as catch, _default$48 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, discriminatedUnion, e164$1 as e164, email$1 as email, emoji$1 as emoji, 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, map, 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 };
+	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, $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, $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, $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, $ZodMap, $ZodMapDef, $ZodMapInternals, $ZodMapParams, $ZodNaN, $ZodNaNDef, $ZodNaNInternals, $ZodNaNParams, $ZodNanoID, $ZodNanoIDDef, $ZodNanoIDInternals, $ZodNanoIDParams, $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, $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, JSONSchemaMeta, NEVER, Params, ParseContext, ParseContextInternal, ParsePayload, SomeType, StringFormatParams, TimePrecision, ToTemplateLiteral, TypeParams, _$ZodType, _$ZodTypeInternals, _any, _array, _base64, _base64url, _bigint, _boolean, _catch, _check, _cidrv4, _cidrv6, _coercedBigint, _coercedBoolean, _coercedDate, _coercedNumber, _coercedString, _cuid, _cuid2, _custom, _date, _decode, _decodeAsync, _default$47 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, _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, _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, clone, config, decode, decodeAsync, encode, encodeAsync, flattenError, formatError, globalConfig, globalRegistry, input, isValidBase64, isValidBase64URL, isValidJWT, locales, output, output as infer, parse, parseAsync, prettifyError, regexes, registry, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, toDotPath, toJSONSchema, treeifyError, util, version };
+	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, ZodFile, ZodFirstPartyTypeKind, ZodFloat32, ZodFloat64, ZodFunction, ZodGUID, ZodIPv4, ZodIPv6, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, ZodInt, ZodInt32, ZodIntersection, ZodIssue, ZodIssueCode, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPromise, ZodRawShape, ZodReadonly, ZodRealError, ZodRecord, ZodSafeParseError, ZodSafeParseResult, ZodSafeParseSuccess, ZodSet, 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, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _catch$1 as catch, _default$48 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, _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, discriminatedUnion, e164$1 as e164, email$1 as email, emoji$1 as emoji, encode$1 as encode, encodeAsync$1 as encodeAsync, file, flattenError, float32, float64, formatError, 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, map, 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 };
+	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 {};