@shopify/cli-kit 1.0.1 → 1.0.4

package/dist/index.d.ts

@@ -31,12 +31,12 @@ declare class Subscription implements SubscriptionLike {
     closed: boolean;
     private _parentage;
     /**
-     * The list of registered teardowns to execute upon unsubscription. Adding and removing from this
+     * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
      * list occurs in the {@link #add} and {@link #remove} methods.
      */
-    private _teardowns;
+    private _finalizers;
     /**
-     * @param initialTeardown A function executed first as part of the teardown
+     * @param initialTeardown A function executed first as part of the finalization
      * process that is kicked off when {@link #unsubscribe} is called.
      */
     constructor(initialTeardown?: (() => void) | undefined);
@@ -48,12 +48,12 @@ declare class Subscription implements SubscriptionLike {
      */
     unsubscribe(): void;
     /**
-     * Adds a teardown to this subscription, so that teardown will be unsubscribed/called
+     * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
      * when this subscription is unsubscribed. If this subscription is already {@link #closed},
-     * because it has already been unsubscribed, then whatever teardown is passed to it
-     * will automatically be executed (unless the teardown itself is also a closed subscription).
+     * because it has already been unsubscribed, then whatever finalizer is passed to it
+     * will automatically be executed (unless the finalizer itself is also a closed subscription).
      *
-     * Closed Subscriptions cannot be added as teardowns to any subscription. Adding a closed
+     * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
      * subscription to a any subscription will result in no operation. (A noop).
      *
      * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
@@ -63,7 +63,7 @@ declare class Subscription implements SubscriptionLike {
      * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
      * will need to be removed manually with {@link #remove}
      *
-     * @param teardown The teardown logic to add to this subscription.
+     * @param teardown The finalization logic to add to this subscription.
      */
     add(teardown: TeardownLogic): void;
     /**
@@ -86,18 +86,18 @@ declare class Subscription implements SubscriptionLike {
      */
     private _removeParent;
     /**
-     * Removes a teardown from this subscription that was previously added with the {@link #add} method.
+     * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
      *
      * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
      * from every other `Subscription` they have been added to. This means that using the `remove` method
      * is not a common thing and should be used thoughtfully.
      *
-     * If you add the same teardown instance of a function or an unsubscribable object to a `Subcription` instance
+     * If you add the same finalizer instance of a function or an unsubscribable object to a `Subcription` instance
      * more than once, you will need to call `remove` the same number of times to remove all instances.
      *
-     * All teardown instances are removed to free up memory upon unsubscription.
+     * All finalizer instances are removed to free up memory upon unsubscription.
      *
-     * @param teardown The teardown to remove from this subscription
+     * @param teardown The finalizer to remove from this subscription
      */
     remove(teardown: Exclude<TeardownLogic, void>): void;
 }
@@ -344,6 +344,7 @@ declare class Observable<T> implements Subscribable<T> {
  */
 declare class Subject<T> extends Observable<T> implements SubscriptionLike {
     closed: boolean;
+    private currentObservers;
     /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
     observers: Observer<T>[];
     /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
@@ -1435,6 +1436,9 @@ declare class Fatal extends Error {
  */
 declare class Abort extends Fatal {
 }
+declare class AbortSilent extends Fatal {
+    constructor();
+}
 /**
  * A bug error is an error that represents a bug and therefore should be reported.
  */
@@ -1451,6 +1455,8 @@ type error$1_Fatal = Fatal;
 declare const error$1_Fatal: typeof Fatal;
 type error$1_Abort = Abort;
 declare const error$1_Abort: typeof Abort;
+type error$1_AbortSilent = AbortSilent;
+declare const error$1_AbortSilent: typeof AbortSilent;
 type error$1_Bug = Bug;
 declare const error$1_Bug: typeof Bug;
 declare const error$1_handler: typeof handler;
@@ -1458,6 +1464,7 @@ declare namespace error$1 {
   export {
     error$1_Fatal as Fatal,
     error$1_Abort as Abort,
+    error$1_AbortSilent as AbortSilent,
     error$1_Bug as Bug,
     error$1_handler as handler,
   };
@@ -1639,6 +1646,7 @@ Promise<ExecaReturnValue<StdoutErrorType>>;
 
 interface ExecOptions {
     cwd?: string;
+    env?: any;
     stdout?: Writable;
     stderr?: Writable;
 }
@@ -1665,7 +1673,7 @@ declare namespace system {
   };
 }
 
-declare function create(templateContent: string): (data: object) => Promise<string>;
+declare function create$1(templateContent: string): (data: object) => Promise<string>;
 /**
  * Given a directory, it traverses the files and directories recursively
  * and replaces variables in directory and file names, and files' content
@@ -1677,11 +1685,10 @@ declare function create(templateContent: string): (data: object) => Promise<stri
  */
 declare function recursiveDirectoryCopy(from: string, to: string, data: any): Promise<void>;
 
-declare const template_create: typeof create;
 declare const template_recursiveDirectoryCopy: typeof recursiveDirectoryCopy;
 declare namespace template {
   export {
-    template_create as create,
+    create$1 as create,
     template_recursiveDirectoryCopy as recursiveDirectoryCopy,
   };
 }
@@ -3648,6 +3655,15 @@ declare const newline: () => void;
  */
 declare const error: (content: Fatal) => void;
 declare function stringifyMessage(message: Message): string;
+/**
+ * Use this function when you have multiple concurrent processes that send data events
+ * and we need to output them ensuring that they can visually differenciated by the user.
+ *
+ * @param index {number} The index of the process being run. This is used to determine the color.
+ * @param prefix {string} The prefix to include in the standard output data to differenciate logs.
+ * @param process The callback that's called with a Writable instance to send events through.
+ */
+declare function concurrent(index: number, prefix: string, callback: (stdout: Writable, stderr: Writable) => Promise<void>): Promise<void>;
 
 declare const output$1_token: typeof token;
 type output$1_Message = Message;
@@ -3662,6 +3678,7 @@ declare const output$1_warn: typeof warn;
 declare const output$1_newline: typeof newline;
 declare const output$1_error: typeof error;
 declare const output$1_stringifyMessage: typeof stringifyMessage;
+declare const output$1_concurrent: typeof concurrent;
 declare namespace output$1 {
   export {
     output$1_token as token,
@@ -3677,6 +3694,7 @@ declare namespace output$1 {
     output$1_newline as newline,
     output$1_error as error,
     output$1_stringifyMessage as stringifyMessage,
+    output$1_concurrent as concurrent,
   };
 }
 
@@ -3696,9 +3714,10 @@ declare function dependencyManagerUsedForCreating(env?: NodeJS.ProcessEnv): Depe
  * Installs the dependencies in the given directory.
  * @param directory {string} The directory that contains the package.json
  * @param dependencyManager {DependencyManager} The dependency manager to use to install the dependencies.
- * @returns
+ * @param stdout {Writable} Standard output stream.
+ * @returns stderr {Writable} Standard error stream.
  */
-declare function install(directory: string, dependencyManager: DependencyManager, stdout?: Writable): Promise<void>;
+declare function install(directory: string, dependencyManager: DependencyManager, stdout?: Writable, stderr?: Writable): Promise<void>;
 
 type dependency_DependencyManager = DependencyManager;
 declare const dependency_DependencyManager: typeof DependencyManager;
@@ -3945,6 +3964,9 @@ declare namespace session {
   };
 }
 
+declare type Primitive = string | number | bigint | boolean | null | undefined;
+declare type Scalars = Primitive | Primitive[];
+
 declare namespace util {
     type AssertEqual<T, Expected> = [T] extends [Expected] ? [Expected] extends [T] ? true : false : false;
     function assertNever(_x: never): never;
@@ -3968,6 +3990,7 @@ declare const ZodIssueCode: {
     invalid_type: "invalid_type";
     custom: "custom";
     invalid_union: "invalid_union";
+    invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";
     unrecognized_keys: "unrecognized_keys";
     invalid_arguments: "invalid_arguments";
@@ -3997,6 +4020,10 @@ interface ZodInvalidUnionIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_union;
     unionErrors: ZodError[];
 }
+interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
 interface ZodInvalidEnumValueIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_enum_value;
     options: (string | number)[];
@@ -4021,13 +4048,13 @@ interface ZodTooSmallIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_small;
     minimum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number";
+    type: "array" | "string" | "number" | "set";
 }
 interface ZodTooBigIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_big;
     maximum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number";
+    type: "array" | "string" | "number" | "set";
 }
 interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_intersection_types;
@@ -4045,7 +4072,7 @@ interface ZodCustomIssue extends ZodIssueBase {
 declare type DenormalizedError = {
     [k: string]: DenormalizedError | string[];
 };
-declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
+declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
 declare type ZodIssue = ZodIssueOptionalMessage & {
     message: string;
 };
@@ -4068,7 +4095,13 @@ declare class ZodError<T = any> extends Error {
     get isEmpty(): boolean;
     addIssue: (sub: ZodIssue) => void;
     addIssues: (subs?: ZodIssue[]) => void;
-    flatten: <U = string>(mapper?: (issue: ZodIssue) => U) => {
+    flatten(mapper?: (issue: ZodIssue) => string): {
+        formErrors: string[];
+        fieldErrors: {
+            [k: string]: string[];
+        };
+    };
+    flatten<U>(mapper?: (issue: ZodIssue) => U): {
         formErrors: U[];
         fieldErrors: {
             [k: string]: U[];
@@ -4123,7 +4156,7 @@ declare const ZodParsedType: {
     set: "set";
 };
 declare type ZodParsedType = keyof typeof ZodParsedType;
-declare const getParsedType: (data: any, cache?: Map<any, "function" | "number" | "string" | "nan" | "integer" | "float" | "boolean" | "date" | "bigint" | "symbol" | "undefined" | "null" | "array" | "object" | "unknown" | "promise" | "void" | "never" | "map" | "set"> | undefined) => ZodParsedType;
+declare const getParsedType: (data: any) => ZodParsedType;
 declare const makeIssue: (params: {
     data: any;
     path: (string | number)[];
@@ -4139,13 +4172,15 @@ declare type ParsePathComponent = string | number;
 declare type ParsePath = ParsePathComponent[];
 declare const EMPTY_PATH: ParsePath;
 interface ParseContext {
+    readonly common: {
+        readonly issues: ZodIssue[];
+        readonly contextualErrorMap?: ZodErrorMap;
+        readonly async: boolean;
+        readonly typeCache: Map<any, ZodParsedType> | undefined;
+    };
     readonly path: ParsePath;
-    readonly issues: ZodIssue[];
     readonly schemaErrorMap?: ZodErrorMap;
-    readonly contextualErrorMap?: ZodErrorMap;
-    readonly async: boolean;
     readonly parent: ParseContext | null;
-    readonly typeCache: Map<any, ZodParsedType>;
     readonly data: any;
     readonly parsedType: ZodParsedType;
 }
@@ -4229,6 +4264,14 @@ declare type ZodTypeAny = ZodType<any, any, any>;
 declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
 declare type input<T extends ZodType<any, any, any>> = T["_input"];
 declare type output<T extends ZodType<any, any, any>> = T["_output"];
+declare type allKeys<T> = T extends any ? keyof T : never;
+declare type TypeOfFlattenedError<T extends ZodType<any, any, any>, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in allKeys<TypeOf<T>>]?: U[];
+    };
+};
+declare type TypeOfFormErrors<T extends ZodType<any, any, any>> = TypeOfFlattenedError<T>;
 
 declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
@@ -4250,13 +4293,15 @@ declare type SafeParseError<Input> = {
     error: ZodError<Input>;
 };
 declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
     readonly _type: Output;
     readonly _output: Output;
     readonly _input: Input;
     readonly _def: Def;
     get description(): string | undefined;
     abstract _parse(input: ParseInput): ParseReturnType<Output>;
+    _getType(input: ParseInput): string;
+    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
     _processInputParams(input: ParseInput): {
         status: ParseStatus;
         ctx: ParseContext;
@@ -4269,10 +4314,6 @@ declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Inpu
     safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
     spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
-    /** The .is method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    is: never;
-    /** The .check method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    check: never;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, RefinedOutput>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, RefinedOutput>;
@@ -4489,7 +4530,9 @@ declare namespace objectUtil {
     type optionalKeys<T extends object> = {
         [k in keyof T]: undefined extends T[k] ? k : never;
     }[keyof T];
-    type requiredKeys<T extends object> = Exclude<keyof T, optionalKeys<T>>;
+    type requiredKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? never : k;
+    }[keyof T];
     export type addQuestionMarks<T extends object> = {
         [k in optionalKeys<T>]?: T[k];
     } & {
@@ -4514,8 +4557,6 @@ declare type extendShape<A, B> = {
     [k in keyof B]: B[k];
 };
 declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
-declare type Primitive = string | number | bigint | boolean | null | undefined;
-declare type Scalars = Primitive | Primitive[];
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodObject;
     shape: () => T;
@@ -4594,15 +4635,46 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
     static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
 }
 declare type AnyZodObject = ZodObject<any, any, any>;
-declare type ZodUnionOptions = [ZodTypeAny, ...ZodTypeAny[]];
-interface ZodUnionDef<T extends ZodUnionOptions = [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]> extends ZodTypeDef {
+declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
+    ZodTypeAny,
+    ZodTypeAny,
+    ...ZodTypeAny[]
+]>> extends ZodTypeDef {
     options: T;
     typeName: ZodFirstPartyTypeKind.ZodUnion;
 }
 declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T_1 extends [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+}
+declare type ZodDiscriminatedUnionOption<Discriminator extends string, DiscriminatorValue extends Primitive> = ZodObject<{
+    [key in Discriminator]: ZodLiteral<DiscriminatorValue>;
+} & ZodRawShape, any, any>;
+interface ZodDiscriminatedUnionDef<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> extends ZodTypeDef {
+    discriminator: Discriminator;
+    options: Map<DiscriminatorValue, Option>;
+    typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
+}
+declare class ZodDiscriminatedUnion<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> extends ZodType<Option["_output"], ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>, Option["_input"]> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get discriminator(): Discriminator;
+    get validDiscriminatorValues(): DiscriminatorValue[];
+    get options(): Map<DiscriminatorValue, Option>;
+    /**
+     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+     * have a different value for each object in the union.
+     * @param discriminator the name of the discriminator property
+     * @param types an array of object schemas
+     * @param params
+     */
+    static create<Discriminator extends string, DiscriminatorValue extends Primitive, Types extends [
+        ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
+        ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>,
+        ...ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>[]
+    ]>(discriminator: Discriminator, types: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>;
 }
 interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     left: T;
@@ -4614,7 +4686,7 @@ declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extend
     static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
 }
 declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-declare type AssertArray<T extends any> = T extends any[] ? T : never;
+declare type AssertArray<T> = T extends any[] ? T : never;
 declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
     [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_output"] : never;
 }>;
@@ -4640,7 +4712,8 @@ interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeA
     typeName: ZodFirstPartyTypeKind.ZodRecord;
 }
 declare type KeySchema = ZodType<string | number | symbol, any, any>;
-declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Record<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, Record<Key["_input"], Value["_input"]>> {
+declare type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
     get keySchema(): Key;
     get valueSchema(): Value;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -4660,9 +4733,21 @@ declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeA
 interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     valueType: Value;
     typeName: ZodFirstPartyTypeKind.ZodSet;
+    minSize: {
+        value: number;
+        message?: string;
+    } | null;
+    maxSize: {
+        value: number;
+        message?: string;
+    } | null;
 }
 declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    min(minSize: number, message?: errorUtil.ErrMessage): this;
+    max(maxSize: number, message?: errorUtil.ErrMessage): this;
+    size(size: number, message?: errorUtil.ErrMessage): this;
+    nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
     static create: <Value_1 extends ZodTypeAny = ZodTypeAny>(valueType: Value_1, params?: RawCreateParams) => ZodSet<Value_1>;
 }
 interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -4692,11 +4777,11 @@ declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDe
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
 }
-interface ZodLiteralDef<T extends any = any> extends ZodTypeDef {
+interface ZodLiteralDef<T = any> extends ZodTypeDef {
     value: T;
     typeName: ZodFirstPartyTypeKind.ZodLiteral;
 }
-declare class ZodLiteral<T extends any> extends ZodType<T, ZodLiteralDef<T>> {
+declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
     static create: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
@@ -4734,6 +4819,7 @@ declare type EnumLike = {
 };
 declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>> {
     _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+    get enum(): T;
     static create: <T_1 extends EnumLike>(values: T_1, params?: RawCreateParams) => ZodNativeEnum<T_1>;
 }
 interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -4801,6 +4887,13 @@ declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<
     removeDefault(): T;
     static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
 }
+interface ZodNaNDef extends ZodTypeDef {
+    typeName: ZodFirstPartyTypeKind.ZodNaN;
+}
+declare class ZodNaN extends ZodType<number, ZodNaNDef> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    static create: (params?: RawCreateParams) => ZodNaN;
+}
 declare const custom: <T>(check?: ((data: unknown) => any) | undefined, params?: Parameters<ZodTypeAny["refine"]>[1]) => ZodType<T, ZodTypeDef, T>;
 
 declare const late: {
@@ -4809,6 +4902,7 @@ declare const late: {
 declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
     ZodNumber = "ZodNumber",
+    ZodNaN = "ZodNaN",
     ZodBigInt = "ZodBigInt",
     ZodBoolean = "ZodBoolean",
     ZodDate = "ZodDate",
@@ -4821,6 +4915,7 @@ declare enum ZodFirstPartyTypeKind {
     ZodArray = "ZodArray",
     ZodObject = "ZodObject",
     ZodUnion = "ZodUnion",
+    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
     ZodIntersection = "ZodIntersection",
     ZodTuple = "ZodTuple",
     ZodRecord = "ZodRecord",
@@ -4837,10 +4932,11 @@ declare enum ZodFirstPartyTypeKind {
     ZodDefault = "ZodDefault",
     ZodPromise = "ZodPromise"
 }
-declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any, any, any> | ZodUnion<any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodPromise<any>;
+declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodPromise<any>;
 declare const instanceOfType: <T extends new (...args: any[]) => any>(cls: T, params?: Parameters<ZodTypeAny["refine"]>[1]) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
 declare const stringType: (params?: RawCreateParams) => ZodString;
 declare const numberType: (params?: RawCreateParams) => ZodNumber;
+declare const nanType: (params?: RawCreateParams) => ZodNaN;
 declare const bigIntType: (params?: RawCreateParams) => ZodBigInt;
 declare const booleanType: (params?: RawCreateParams) => ZodBoolean;
 declare const dateType: (params?: RawCreateParams) => ZodDate;
@@ -4853,7 +4949,8 @@ declare const voidType: (params?: RawCreateParams) => ZodVoid;
 declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T, "many">;
 declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
 declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;
-declare const unionType: <T extends [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
+declare const unionType: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
+declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
 declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: RawCreateParams) => ZodIntersection<T, U>;
 declare const tupleType: <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T, params?: RawCreateParams) => ZodTuple<T, null>;
 declare const recordType: typeof ZodRecord.create;
@@ -4873,225 +4970,241 @@ declare const ostring: () => ZodOptional<ZodString>;
 declare const onumber: () => ZodOptional<ZodNumber>;
 declare const oboolean: () => ZodOptional<ZodBoolean>;
 
-//# sourceMappingURL=external.d.ts.map
-
-type external_d_ZodParsedType = ZodParsedType;
-declare const external_d_getParsedType: typeof getParsedType;
-declare const external_d_makeIssue: typeof makeIssue;
-type external_d_ParseParams = ParseParams;
-type external_d_ParsePathComponent = ParsePathComponent;
-type external_d_ParsePath = ParsePath;
-declare const external_d_EMPTY_PATH: typeof EMPTY_PATH;
-type external_d_ParseContext = ParseContext;
-type external_d_ParseInput = ParseInput;
-declare const external_d_addIssueToContext: typeof addIssueToContext;
-type external_d_ObjectPair = ObjectPair;
-type external_d_ParseStatus = ParseStatus;
-declare const external_d_ParseStatus: typeof ParseStatus;
-type external_d_ParseResult = ParseResult;
-declare const external_d_INVALID: typeof INVALID;
-declare const external_d_DIRTY: typeof DIRTY;
-declare const external_d_OK: typeof OK;
-type external_d_SyncParseReturnType<T = any> = SyncParseReturnType<T>;
-type external_d_AsyncParseReturnType<T> = AsyncParseReturnType<T>;
-type external_d_ParseReturnType<T> = ParseReturnType<T>;
-declare const external_d_isAborted: typeof isAborted;
-declare const external_d_isDirty: typeof isDirty;
-declare const external_d_isValid: typeof isValid;
-declare const external_d_isAsync: typeof isAsync;
-declare const external_d_oboolean: typeof oboolean;
-declare const external_d_onumber: typeof onumber;
-declare const external_d_ostring: typeof ostring;
-type external_d_RefinementCtx = RefinementCtx;
-type external_d_ZodRawShape = ZodRawShape;
-type external_d_ZodTypeAny = ZodTypeAny;
-type external_d_TypeOf<T extends ZodType<any, any, any>> = TypeOf<T>;
-type external_d_input<T extends ZodType<any, any, any>> = input<T>;
-type external_d_output<T extends ZodType<any, any, any>> = output<T>;
-type external_d_CustomErrorParams = CustomErrorParams;
-type external_d_ZodTypeDef = ZodTypeDef;
-type external_d_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
-type external_d_SafeParseError<Input> = SafeParseError<Input>;
-type external_d_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
-type external_d_ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodType<Output, Def, Input>;
-declare const external_d_ZodType: typeof ZodType;
-type external_d_ZodStringDef = ZodStringDef;
-type external_d_ZodString = ZodString;
-declare const external_d_ZodString: typeof ZodString;
-type external_d_ZodNumberDef = ZodNumberDef;
-type external_d_ZodNumber = ZodNumber;
-declare const external_d_ZodNumber: typeof ZodNumber;
-type external_d_ZodBigIntDef = ZodBigIntDef;
-type external_d_ZodBigInt = ZodBigInt;
-declare const external_d_ZodBigInt: typeof ZodBigInt;
-type external_d_ZodBooleanDef = ZodBooleanDef;
-type external_d_ZodBoolean = ZodBoolean;
-declare const external_d_ZodBoolean: typeof ZodBoolean;
-type external_d_ZodDateDef = ZodDateDef;
-type external_d_ZodDate = ZodDate;
-declare const external_d_ZodDate: typeof ZodDate;
-type external_d_ZodUndefinedDef = ZodUndefinedDef;
-type external_d_ZodUndefined = ZodUndefined;
-declare const external_d_ZodUndefined: typeof ZodUndefined;
-type external_d_ZodNullDef = ZodNullDef;
-type external_d_ZodNull = ZodNull;
-declare const external_d_ZodNull: typeof ZodNull;
-type external_d_ZodAnyDef = ZodAnyDef;
-type external_d_ZodAny = ZodAny;
-declare const external_d_ZodAny: typeof ZodAny;
-type external_d_ZodUnknownDef = ZodUnknownDef;
-type external_d_ZodUnknown = ZodUnknown;
-declare const external_d_ZodUnknown: typeof ZodUnknown;
-type external_d_ZodNeverDef = ZodNeverDef;
-type external_d_ZodNever = ZodNever;
-declare const external_d_ZodNever: typeof ZodNever;
-type external_d_ZodVoidDef = ZodVoidDef;
-type external_d_ZodVoid = ZodVoid;
-declare const external_d_ZodVoid: typeof ZodVoid;
-type external_d_ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> = ZodArrayDef<T>;
-type external_d_ArrayCardinality = ArrayCardinality;
-type external_d_ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = ZodArray<T, Cardinality>;
-declare const external_d_ZodArray: typeof ZodArray;
-type external_d_ZodNonEmptyArray<T extends ZodTypeAny> = ZodNonEmptyArray<T>;
-declare const external_d_objectUtil: typeof objectUtil;
-type external_d_extendShape<A, B> = extendShape<A, B>;
-type external_d_Primitive = Primitive;
-type external_d_Scalars = Scalars;
-type external_d_ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> = ZodObjectDef<T, UnknownKeys, Catchall>;
-type external_d_baseObjectOutputType<Shape extends ZodRawShape> = baseObjectOutputType<Shape>;
-type external_d_objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectOutputType<Shape, Catchall>;
-type external_d_baseObjectInputType<Shape extends ZodRawShape> = baseObjectInputType<Shape>;
-type external_d_objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectInputType<Shape, Catchall>;
-type external_d_SomeZodObject = SomeZodObject;
-type external_d_ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> = ZodObject<T, UnknownKeys, Catchall, Output, Input>;
-declare const external_d_ZodObject: typeof ZodObject;
-type external_d_AnyZodObject = AnyZodObject;
-type external_d_ZodUnionDef<T extends ZodUnionOptions = [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]> = ZodUnionDef<T>;
-type external_d_ZodUnion<T extends ZodUnionOptions> = ZodUnion<T>;
-declare const external_d_ZodUnion: typeof ZodUnion;
-type external_d_ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> = ZodIntersectionDef<T, U>;
-type external_d_ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> = ZodIntersection<T, U>;
-declare const external_d_ZodIntersection: typeof ZodIntersection;
-type external_d_ZodTupleItems = ZodTupleItems;
-type external_d_AssertArray<T extends any> = AssertArray<T>;
-type external_d_OutputTypeOfTuple<T extends ZodTupleItems | []> = OutputTypeOfTuple<T>;
-type external_d_OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = OutputTypeOfTupleWithRest<T, Rest>;
-type external_d_InputTypeOfTuple<T extends ZodTupleItems | []> = InputTypeOfTuple<T>;
-type external_d_InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = InputTypeOfTupleWithRest<T, Rest>;
-type external_d_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> = ZodTupleDef<T, Rest>;
-type external_d_ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> = ZodTuple<T, Rest>;
-declare const external_d_ZodTuple: typeof ZodTuple;
-type external_d_ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecordDef<Key, Value>;
-type external_d_ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecord<Key, Value>;
-declare const external_d_ZodRecord: typeof ZodRecord;
-type external_d_ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMapDef<Key, Value>;
-type external_d_ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMap<Key, Value>;
-declare const external_d_ZodMap: typeof ZodMap;
-type external_d_ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> = ZodSetDef<Value>;
-type external_d_ZodSet<Value extends ZodTypeAny = ZodTypeAny> = ZodSet<Value>;
-declare const external_d_ZodSet: typeof ZodSet;
-type external_d_ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> = ZodFunctionDef<Args, Returns>;
-type external_d_OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = OuterTypeOfFunction<Args, Returns>;
-type external_d_InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = InnerTypeOfFunction<Args, Returns>;
-type external_d_ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = ZodFunction<Args, Returns>;
-declare const external_d_ZodFunction: typeof ZodFunction;
-type external_d_ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> = ZodLazyDef<T>;
-type external_d_ZodLazy<T extends ZodTypeAny> = ZodLazy<T>;
-declare const external_d_ZodLazy: typeof ZodLazy;
-type external_d_ZodLiteralDef<T extends any = any> = ZodLiteralDef<T>;
-type external_d_ZodLiteral<T extends any> = ZodLiteral<T>;
-declare const external_d_ZodLiteral: typeof ZodLiteral;
-type external_d_ArrayKeys = ArrayKeys;
-type external_d_Indices<T> = Indices<T>;
-type external_d_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
-type external_d_ZodEnum<T extends [string, ...string[]]> = ZodEnum<T>;
-declare const external_d_ZodEnum: typeof ZodEnum;
-type external_d_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
-type external_d_ZodNativeEnum<T extends EnumLike> = ZodNativeEnum<T>;
-declare const external_d_ZodNativeEnum: typeof ZodNativeEnum;
-type external_d_ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> = ZodPromiseDef<T>;
-type external_d_ZodPromise<T extends ZodTypeAny> = ZodPromise<T>;
-declare const external_d_ZodPromise: typeof ZodPromise;
-type external_d_Refinement<T> = Refinement<T>;
-type external_d_SuperRefinement<T> = SuperRefinement<T>;
-type external_d_RefinementEffect<T> = RefinementEffect<T>;
-type external_d_TransformEffect<T> = TransformEffect<T>;
-type external_d_PreprocessEffect<T> = PreprocessEffect<T>;
-type external_d_Effect<T> = Effect<T>;
-type external_d_ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> = ZodEffectsDef<T>;
-type external_d_ZodEffects<T extends ZodTypeAny, Output = T["_output"], Input = T["_input"]> = ZodEffects<T, Output, Input>;
-declare const external_d_ZodEffects: typeof ZodEffects;
-type external_d_ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> = ZodOptionalDef<T>;
-type external_d_ZodOptionalType<T extends ZodTypeAny> = ZodOptionalType<T>;
-type external_d_ZodOptional<T extends ZodTypeAny> = ZodOptional<T>;
-declare const external_d_ZodOptional: typeof ZodOptional;
-type external_d_ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> = ZodNullableDef<T>;
-type external_d_ZodNullableType<T extends ZodTypeAny> = ZodNullableType<T>;
-type external_d_ZodNullable<T extends ZodTypeAny> = ZodNullable<T>;
-declare const external_d_ZodNullable: typeof ZodNullable;
-type external_d_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
-type external_d_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
-declare const external_d_ZodDefault: typeof ZodDefault;
-declare const external_d_custom: typeof custom;
-declare const external_d_late: typeof late;
-type external_d_ZodFirstPartyTypeKind = ZodFirstPartyTypeKind;
-declare const external_d_ZodFirstPartyTypeKind: typeof ZodFirstPartyTypeKind;
-type external_d_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
-type external_d_ZodIssueCode = ZodIssueCode;
-type external_d_ZodIssueBase = ZodIssueBase;
-type external_d_ZodInvalidTypeIssue = ZodInvalidTypeIssue;
-type external_d_ZodUnrecognizedKeysIssue = ZodUnrecognizedKeysIssue;
-type external_d_ZodInvalidUnionIssue = ZodInvalidUnionIssue;
-type external_d_ZodInvalidEnumValueIssue = ZodInvalidEnumValueIssue;
-type external_d_ZodInvalidArgumentsIssue = ZodInvalidArgumentsIssue;
-type external_d_ZodInvalidReturnTypeIssue = ZodInvalidReturnTypeIssue;
-type external_d_ZodInvalidDateIssue = ZodInvalidDateIssue;
-type external_d_StringValidation = StringValidation;
-type external_d_ZodInvalidStringIssue = ZodInvalidStringIssue;
-type external_d_ZodTooSmallIssue = ZodTooSmallIssue;
-type external_d_ZodTooBigIssue = ZodTooBigIssue;
-type external_d_ZodInvalidIntersectionTypesIssue = ZodInvalidIntersectionTypesIssue;
-type external_d_ZodNotMultipleOfIssue = ZodNotMultipleOfIssue;
-type external_d_ZodCustomIssue = ZodCustomIssue;
-type external_d_DenormalizedError = DenormalizedError;
-type external_d_ZodIssueOptionalMessage = ZodIssueOptionalMessage;
-type external_d_ZodIssue = ZodIssue;
-declare const external_d_quotelessJson: typeof quotelessJson;
-type external_d_ZodFormattedError<T> = ZodFormattedError<T>;
-type external_d_ZodError<T = any> = ZodError<T>;
-declare const external_d_ZodError: typeof ZodError;
-type external_d_IssueData = IssueData;
-type external_d_MakeErrorData = MakeErrorData;
-type external_d_ZodErrorMap = ZodErrorMap;
-declare const external_d_defaultErrorMap: typeof defaultErrorMap;
-declare const external_d_overrideErrorMap: typeof overrideErrorMap;
-declare const external_d_setErrorMap: typeof setErrorMap;
-declare namespace external_d {
+type mod_ZodParsedType = ZodParsedType;
+declare const mod_getParsedType: typeof getParsedType;
+declare const mod_makeIssue: typeof makeIssue;
+type mod_ParseParams = ParseParams;
+type mod_ParsePathComponent = ParsePathComponent;
+type mod_ParsePath = ParsePath;
+declare const mod_EMPTY_PATH: typeof EMPTY_PATH;
+type mod_ParseContext = ParseContext;
+type mod_ParseInput = ParseInput;
+declare const mod_addIssueToContext: typeof addIssueToContext;
+type mod_ObjectPair = ObjectPair;
+type mod_ParseStatus = ParseStatus;
+declare const mod_ParseStatus: typeof ParseStatus;
+type mod_ParseResult = ParseResult;
+declare const mod_INVALID: typeof INVALID;
+declare const mod_DIRTY: typeof DIRTY;
+declare const mod_OK: typeof OK;
+type mod_SyncParseReturnType<T = any> = SyncParseReturnType<T>;
+type mod_AsyncParseReturnType<T> = AsyncParseReturnType<T>;
+type mod_ParseReturnType<T> = ParseReturnType<T>;
+declare const mod_isAborted: typeof isAborted;
+declare const mod_isDirty: typeof isDirty;
+declare const mod_isValid: typeof isValid;
+declare const mod_isAsync: typeof isAsync;
+type mod_Primitive = Primitive;
+type mod_Scalars = Scalars;
+declare const mod_oboolean: typeof oboolean;
+declare const mod_onumber: typeof onumber;
+declare const mod_ostring: typeof ostring;
+type mod_RefinementCtx = RefinementCtx;
+type mod_ZodRawShape = ZodRawShape;
+type mod_ZodTypeAny = ZodTypeAny;
+type mod_TypeOf<T extends ZodType<any, any, any>> = TypeOf<T>;
+type mod_input<T extends ZodType<any, any, any>> = input<T>;
+type mod_output<T extends ZodType<any, any, any>> = output<T>;
+type mod_TypeOfFlattenedError<T extends ZodType<any, any, any>, U = string> = TypeOfFlattenedError<T, U>;
+type mod_TypeOfFormErrors<T extends ZodType<any, any, any>> = TypeOfFormErrors<T>;
+type mod_CustomErrorParams = CustomErrorParams;
+type mod_ZodTypeDef = ZodTypeDef;
+type mod_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
+type mod_SafeParseError<Input> = SafeParseError<Input>;
+type mod_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
+type mod_ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodType<Output, Def, Input>;
+declare const mod_ZodType: typeof ZodType;
+type mod_ZodStringDef = ZodStringDef;
+type mod_ZodString = ZodString;
+declare const mod_ZodString: typeof ZodString;
+type mod_ZodNumberDef = ZodNumberDef;
+type mod_ZodNumber = ZodNumber;
+declare const mod_ZodNumber: typeof ZodNumber;
+type mod_ZodBigIntDef = ZodBigIntDef;
+type mod_ZodBigInt = ZodBigInt;
+declare const mod_ZodBigInt: typeof ZodBigInt;
+type mod_ZodBooleanDef = ZodBooleanDef;
+type mod_ZodBoolean = ZodBoolean;
+declare const mod_ZodBoolean: typeof ZodBoolean;
+type mod_ZodDateDef = ZodDateDef;
+type mod_ZodDate = ZodDate;
+declare const mod_ZodDate: typeof ZodDate;
+type mod_ZodUndefinedDef = ZodUndefinedDef;
+type mod_ZodUndefined = ZodUndefined;
+declare const mod_ZodUndefined: typeof ZodUndefined;
+type mod_ZodNullDef = ZodNullDef;
+type mod_ZodNull = ZodNull;
+declare const mod_ZodNull: typeof ZodNull;
+type mod_ZodAnyDef = ZodAnyDef;
+type mod_ZodAny = ZodAny;
+declare const mod_ZodAny: typeof ZodAny;
+type mod_ZodUnknownDef = ZodUnknownDef;
+type mod_ZodUnknown = ZodUnknown;
+declare const mod_ZodUnknown: typeof ZodUnknown;
+type mod_ZodNeverDef = ZodNeverDef;
+type mod_ZodNever = ZodNever;
+declare const mod_ZodNever: typeof ZodNever;
+type mod_ZodVoidDef = ZodVoidDef;
+type mod_ZodVoid = ZodVoid;
+declare const mod_ZodVoid: typeof ZodVoid;
+type mod_ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> = ZodArrayDef<T>;
+type mod_ArrayCardinality = ArrayCardinality;
+type mod_ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = ZodArray<T, Cardinality>;
+declare const mod_ZodArray: typeof ZodArray;
+type mod_ZodNonEmptyArray<T extends ZodTypeAny> = ZodNonEmptyArray<T>;
+declare const mod_objectUtil: typeof objectUtil;
+type mod_extendShape<A, B> = extendShape<A, B>;
+type mod_ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> = ZodObjectDef<T, UnknownKeys, Catchall>;
+type mod_baseObjectOutputType<Shape extends ZodRawShape> = baseObjectOutputType<Shape>;
+type mod_objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectOutputType<Shape, Catchall>;
+type mod_baseObjectInputType<Shape extends ZodRawShape> = baseObjectInputType<Shape>;
+type mod_objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny> = objectInputType<Shape, Catchall>;
+type mod_SomeZodObject = SomeZodObject;
+type mod_ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> = ZodObject<T, UnknownKeys, Catchall, Output, Input>;
+declare const mod_ZodObject: typeof ZodObject;
+type mod_AnyZodObject = AnyZodObject;
+type mod_ZodUnionDef<T extends ZodUnionOptions = Readonly<[
+    ZodTypeAny,
+    ZodTypeAny,
+    ...ZodTypeAny[]
+]>> = ZodUnionDef<T>;
+type mod_ZodUnion<T extends ZodUnionOptions> = ZodUnion<T>;
+declare const mod_ZodUnion: typeof ZodUnion;
+type mod_ZodDiscriminatedUnionOption<Discriminator extends string, DiscriminatorValue extends Primitive> = ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>;
+type mod_ZodDiscriminatedUnionDef<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> = ZodDiscriminatedUnionDef<Discriminator, DiscriminatorValue, Option>;
+type mod_ZodDiscriminatedUnion<Discriminator extends string, DiscriminatorValue extends Primitive, Option extends ZodDiscriminatedUnionOption<Discriminator, DiscriminatorValue>> = ZodDiscriminatedUnion<Discriminator, DiscriminatorValue, Option>;
+declare const mod_ZodDiscriminatedUnion: typeof ZodDiscriminatedUnion;
+type mod_ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> = ZodIntersectionDef<T, U>;
+type mod_ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> = ZodIntersection<T, U>;
+declare const mod_ZodIntersection: typeof ZodIntersection;
+type mod_ZodTupleItems = ZodTupleItems;
+type mod_AssertArray<T> = AssertArray<T>;
+type mod_OutputTypeOfTuple<T extends ZodTupleItems | []> = OutputTypeOfTuple<T>;
+type mod_OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = OutputTypeOfTupleWithRest<T, Rest>;
+type mod_InputTypeOfTuple<T extends ZodTupleItems | []> = InputTypeOfTuple<T>;
+type mod_InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = InputTypeOfTupleWithRest<T, Rest>;
+type mod_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> = ZodTupleDef<T, Rest>;
+type mod_ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> = ZodTuple<T, Rest>;
+declare const mod_ZodTuple: typeof ZodTuple;
+type mod_ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecordDef<Key, Value>;
+type mod_ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecord<Key, Value>;
+declare const mod_ZodRecord: typeof ZodRecord;
+type mod_ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMapDef<Key, Value>;
+type mod_ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMap<Key, Value>;
+declare const mod_ZodMap: typeof ZodMap;
+type mod_ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> = ZodSetDef<Value>;
+type mod_ZodSet<Value extends ZodTypeAny = ZodTypeAny> = ZodSet<Value>;
+declare const mod_ZodSet: typeof ZodSet;
+type mod_ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> = ZodFunctionDef<Args, Returns>;
+type mod_OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = OuterTypeOfFunction<Args, Returns>;
+type mod_InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = InnerTypeOfFunction<Args, Returns>;
+type mod_ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = ZodFunction<Args, Returns>;
+declare const mod_ZodFunction: typeof ZodFunction;
+type mod_ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> = ZodLazyDef<T>;
+type mod_ZodLazy<T extends ZodTypeAny> = ZodLazy<T>;
+declare const mod_ZodLazy: typeof ZodLazy;
+type mod_ZodLiteralDef<T = any> = ZodLiteralDef<T>;
+type mod_ZodLiteral<T> = ZodLiteral<T>;
+declare const mod_ZodLiteral: typeof ZodLiteral;
+type mod_ArrayKeys = ArrayKeys;
+type mod_Indices<T> = Indices<T>;
+type mod_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
+type mod_ZodEnum<T extends [string, ...string[]]> = ZodEnum<T>;
+declare const mod_ZodEnum: typeof ZodEnum;
+type mod_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
+type mod_ZodNativeEnum<T extends EnumLike> = ZodNativeEnum<T>;
+declare const mod_ZodNativeEnum: typeof ZodNativeEnum;
+type mod_ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> = ZodPromiseDef<T>;
+type mod_ZodPromise<T extends ZodTypeAny> = ZodPromise<T>;
+declare const mod_ZodPromise: typeof ZodPromise;
+type mod_Refinement<T> = Refinement<T>;
+type mod_SuperRefinement<T> = SuperRefinement<T>;
+type mod_RefinementEffect<T> = RefinementEffect<T>;
+type mod_TransformEffect<T> = TransformEffect<T>;
+type mod_PreprocessEffect<T> = PreprocessEffect<T>;
+type mod_Effect<T> = Effect<T>;
+type mod_ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> = ZodEffectsDef<T>;
+type mod_ZodEffects<T extends ZodTypeAny, Output = T["_output"], Input = T["_input"]> = ZodEffects<T, Output, Input>;
+declare const mod_ZodEffects: typeof ZodEffects;
+type mod_ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> = ZodOptionalDef<T>;
+type mod_ZodOptionalType<T extends ZodTypeAny> = ZodOptionalType<T>;
+type mod_ZodOptional<T extends ZodTypeAny> = ZodOptional<T>;
+declare const mod_ZodOptional: typeof ZodOptional;
+type mod_ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> = ZodNullableDef<T>;
+type mod_ZodNullableType<T extends ZodTypeAny> = ZodNullableType<T>;
+type mod_ZodNullable<T extends ZodTypeAny> = ZodNullable<T>;
+declare const mod_ZodNullable: typeof ZodNullable;
+type mod_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
+type mod_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
+declare const mod_ZodDefault: typeof ZodDefault;
+type mod_ZodNaNDef = ZodNaNDef;
+type mod_ZodNaN = ZodNaN;
+declare const mod_ZodNaN: typeof ZodNaN;
+declare const mod_custom: typeof custom;
+declare const mod_late: typeof late;
+type mod_ZodFirstPartyTypeKind = ZodFirstPartyTypeKind;
+declare const mod_ZodFirstPartyTypeKind: typeof ZodFirstPartyTypeKind;
+type mod_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
+type mod_ZodIssueCode = ZodIssueCode;
+type mod_ZodIssueBase = ZodIssueBase;
+type mod_ZodInvalidTypeIssue = ZodInvalidTypeIssue;
+type mod_ZodUnrecognizedKeysIssue = ZodUnrecognizedKeysIssue;
+type mod_ZodInvalidUnionIssue = ZodInvalidUnionIssue;
+type mod_ZodInvalidUnionDiscriminatorIssue = ZodInvalidUnionDiscriminatorIssue;
+type mod_ZodInvalidEnumValueIssue = ZodInvalidEnumValueIssue;
+type mod_ZodInvalidArgumentsIssue = ZodInvalidArgumentsIssue;
+type mod_ZodInvalidReturnTypeIssue = ZodInvalidReturnTypeIssue;
+type mod_ZodInvalidDateIssue = ZodInvalidDateIssue;
+type mod_StringValidation = StringValidation;
+type mod_ZodInvalidStringIssue = ZodInvalidStringIssue;
+type mod_ZodTooSmallIssue = ZodTooSmallIssue;
+type mod_ZodTooBigIssue = ZodTooBigIssue;
+type mod_ZodInvalidIntersectionTypesIssue = ZodInvalidIntersectionTypesIssue;
+type mod_ZodNotMultipleOfIssue = ZodNotMultipleOfIssue;
+type mod_ZodCustomIssue = ZodCustomIssue;
+type mod_DenormalizedError = DenormalizedError;
+type mod_ZodIssueOptionalMessage = ZodIssueOptionalMessage;
+type mod_ZodIssue = ZodIssue;
+declare const mod_quotelessJson: typeof quotelessJson;
+type mod_ZodFormattedError<T> = ZodFormattedError<T>;
+type mod_ZodError<T = any> = ZodError<T>;
+declare const mod_ZodError: typeof ZodError;
+type mod_IssueData = IssueData;
+type mod_MakeErrorData = MakeErrorData;
+type mod_ZodErrorMap = ZodErrorMap;
+declare const mod_defaultErrorMap: typeof defaultErrorMap;
+declare const mod_overrideErrorMap: typeof overrideErrorMap;
+declare const mod_setErrorMap: typeof setErrorMap;
+declare namespace mod {
   export {
-    external_d_ZodParsedType as ZodParsedType,
-    external_d_getParsedType as getParsedType,
-    external_d_makeIssue as makeIssue,
-    external_d_ParseParams as ParseParams,
-    external_d_ParsePathComponent as ParsePathComponent,
-    external_d_ParsePath as ParsePath,
-    external_d_EMPTY_PATH as EMPTY_PATH,
-    external_d_ParseContext as ParseContext,
-    external_d_ParseInput as ParseInput,
-    external_d_addIssueToContext as addIssueToContext,
-    external_d_ObjectPair as ObjectPair,
-    external_d_ParseStatus as ParseStatus,
-    external_d_ParseResult as ParseResult,
-    external_d_INVALID as INVALID,
-    external_d_DIRTY as DIRTY,
-    external_d_OK as OK,
-    external_d_SyncParseReturnType as SyncParseReturnType,
-    external_d_AsyncParseReturnType as AsyncParseReturnType,
-    external_d_ParseReturnType as ParseReturnType,
-    external_d_isAborted as isAborted,
-    external_d_isDirty as isDirty,
-    external_d_isValid as isValid,
-    external_d_isAsync as isAsync,
+    mod_ZodParsedType as ZodParsedType,
+    mod_getParsedType as getParsedType,
+    mod_makeIssue as makeIssue,
+    mod_ParseParams as ParseParams,
+    mod_ParsePathComponent as ParsePathComponent,
+    mod_ParsePath as ParsePath,
+    mod_EMPTY_PATH as EMPTY_PATH,
+    mod_ParseContext as ParseContext,
+    mod_ParseInput as ParseInput,
+    mod_addIssueToContext as addIssueToContext,
+    mod_ObjectPair as ObjectPair,
+    mod_ParseStatus as ParseStatus,
+    mod_ParseResult as ParseResult,
+    mod_INVALID as INVALID,
+    mod_DIRTY as DIRTY,
+    mod_OK as OK,
+    mod_SyncParseReturnType as SyncParseReturnType,
+    mod_AsyncParseReturnType as AsyncParseReturnType,
+    mod_ParseReturnType as ParseReturnType,
+    mod_isAborted as isAborted,
+    mod_isDirty as isDirty,
+    mod_isValid as isValid,
+    mod_isAsync as isAsync,
+    mod_Primitive as Primitive,
+    mod_Scalars as Scalars,
     TypeOf as infer,
+    TypeOfFlattenedError as inferFlattenedErrors,
+    TypeOfFormErrors as inferFormErrors,
     ZodEffects as ZodTransformer,
     ZodType as Schema,
     ZodType as ZodSchema,
@@ -5100,6 +5213,7 @@ declare namespace external_d {
     bigIntType as bigint,
     booleanType as boolean,
     dateType as date,
+    discriminatedUnionType as discriminatedUnion,
     effectsType as effect,
     enumType as enum,
     functionType as function,
@@ -5108,16 +5222,17 @@ declare namespace external_d {
     lazyType as lazy,
     literalType as literal,
     mapType as map,
+    nanType as nan,
     nativeEnumType as nativeEnum,
     neverType as never,
     nullType as null,
     nullableType as nullable,
     numberType as number,
     objectType as object,
-    external_d_oboolean as oboolean,
-    external_d_onumber as onumber,
+    mod_oboolean as oboolean,
+    mod_onumber as onumber,
     optionalType as optional,
-    external_d_ostring as ostring,
+    mod_ostring as ostring,
     preprocessType as preprocess,
     promiseType as promise,
     recordType as record,
@@ -5130,144 +5245,150 @@ declare namespace external_d {
     unionType as union,
     unknownType as unknown,
     voidType as void,
-    external_d_RefinementCtx as RefinementCtx,
-    external_d_ZodRawShape as ZodRawShape,
-    external_d_ZodTypeAny as ZodTypeAny,
-    external_d_TypeOf as TypeOf,
-    external_d_input as input,
-    external_d_output as output,
-    external_d_CustomErrorParams as CustomErrorParams,
-    external_d_ZodTypeDef as ZodTypeDef,
-    external_d_SafeParseSuccess as SafeParseSuccess,
-    external_d_SafeParseError as SafeParseError,
-    external_d_SafeParseReturnType as SafeParseReturnType,
-    external_d_ZodType as ZodType,
-    external_d_ZodStringDef as ZodStringDef,
-    external_d_ZodString as ZodString,
-    external_d_ZodNumberDef as ZodNumberDef,
-    external_d_ZodNumber as ZodNumber,
-    external_d_ZodBigIntDef as ZodBigIntDef,
-    external_d_ZodBigInt as ZodBigInt,
-    external_d_ZodBooleanDef as ZodBooleanDef,
-    external_d_ZodBoolean as ZodBoolean,
-    external_d_ZodDateDef as ZodDateDef,
-    external_d_ZodDate as ZodDate,
-    external_d_ZodUndefinedDef as ZodUndefinedDef,
-    external_d_ZodUndefined as ZodUndefined,
-    external_d_ZodNullDef as ZodNullDef,
-    external_d_ZodNull as ZodNull,
-    external_d_ZodAnyDef as ZodAnyDef,
-    external_d_ZodAny as ZodAny,
-    external_d_ZodUnknownDef as ZodUnknownDef,
-    external_d_ZodUnknown as ZodUnknown,
-    external_d_ZodNeverDef as ZodNeverDef,
-    external_d_ZodNever as ZodNever,
-    external_d_ZodVoidDef as ZodVoidDef,
-    external_d_ZodVoid as ZodVoid,
-    external_d_ZodArrayDef as ZodArrayDef,
-    external_d_ArrayCardinality as ArrayCardinality,
-    external_d_ZodArray as ZodArray,
-    external_d_ZodNonEmptyArray as ZodNonEmptyArray,
-    external_d_objectUtil as objectUtil,
-    external_d_extendShape as extendShape,
-    external_d_Primitive as Primitive,
-    external_d_Scalars as Scalars,
-    external_d_ZodObjectDef as ZodObjectDef,
-    external_d_baseObjectOutputType as baseObjectOutputType,
-    external_d_objectOutputType as objectOutputType,
-    external_d_baseObjectInputType as baseObjectInputType,
-    external_d_objectInputType as objectInputType,
-    external_d_SomeZodObject as SomeZodObject,
-    external_d_ZodObject as ZodObject,
-    external_d_AnyZodObject as AnyZodObject,
-    external_d_ZodUnionDef as ZodUnionDef,
-    external_d_ZodUnion as ZodUnion,
-    external_d_ZodIntersectionDef as ZodIntersectionDef,
-    external_d_ZodIntersection as ZodIntersection,
-    external_d_ZodTupleItems as ZodTupleItems,
-    external_d_AssertArray as AssertArray,
-    external_d_OutputTypeOfTuple as OutputTypeOfTuple,
-    external_d_OutputTypeOfTupleWithRest as OutputTypeOfTupleWithRest,
-    external_d_InputTypeOfTuple as InputTypeOfTuple,
-    external_d_InputTypeOfTupleWithRest as InputTypeOfTupleWithRest,
-    external_d_ZodTupleDef as ZodTupleDef,
-    external_d_ZodTuple as ZodTuple,
-    external_d_ZodRecordDef as ZodRecordDef,
-    external_d_ZodRecord as ZodRecord,
-    external_d_ZodMapDef as ZodMapDef,
-    external_d_ZodMap as ZodMap,
-    external_d_ZodSetDef as ZodSetDef,
-    external_d_ZodSet as ZodSet,
-    external_d_ZodFunctionDef as ZodFunctionDef,
-    external_d_OuterTypeOfFunction as OuterTypeOfFunction,
-    external_d_InnerTypeOfFunction as InnerTypeOfFunction,
-    external_d_ZodFunction as ZodFunction,
-    external_d_ZodLazyDef as ZodLazyDef,
-    external_d_ZodLazy as ZodLazy,
-    external_d_ZodLiteralDef as ZodLiteralDef,
-    external_d_ZodLiteral as ZodLiteral,
-    external_d_ArrayKeys as ArrayKeys,
-    external_d_Indices as Indices,
-    external_d_ZodEnumDef as ZodEnumDef,
-    external_d_ZodEnum as ZodEnum,
-    external_d_ZodNativeEnumDef as ZodNativeEnumDef,
-    external_d_ZodNativeEnum as ZodNativeEnum,
-    external_d_ZodPromiseDef as ZodPromiseDef,
-    external_d_ZodPromise as ZodPromise,
-    external_d_Refinement as Refinement,
-    external_d_SuperRefinement as SuperRefinement,
-    external_d_RefinementEffect as RefinementEffect,
-    external_d_TransformEffect as TransformEffect,
-    external_d_PreprocessEffect as PreprocessEffect,
-    external_d_Effect as Effect,
-    external_d_ZodEffectsDef as ZodEffectsDef,
-    external_d_ZodEffects as ZodEffects,
-    external_d_ZodOptionalDef as ZodOptionalDef,
-    external_d_ZodOptionalType as ZodOptionalType,
-    external_d_ZodOptional as ZodOptional,
-    external_d_ZodNullableDef as ZodNullableDef,
-    external_d_ZodNullableType as ZodNullableType,
-    external_d_ZodNullable as ZodNullable,
-    external_d_ZodDefaultDef as ZodDefaultDef,
-    external_d_ZodDefault as ZodDefault,
-    external_d_custom as custom,
-    external_d_late as late,
-    external_d_ZodFirstPartyTypeKind as ZodFirstPartyTypeKind,
-    external_d_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes,
-    external_d_ZodIssueCode as ZodIssueCode,
-    external_d_ZodIssueBase as ZodIssueBase,
-    external_d_ZodInvalidTypeIssue as ZodInvalidTypeIssue,
-    external_d_ZodUnrecognizedKeysIssue as ZodUnrecognizedKeysIssue,
-    external_d_ZodInvalidUnionIssue as ZodInvalidUnionIssue,
-    external_d_ZodInvalidEnumValueIssue as ZodInvalidEnumValueIssue,
-    external_d_ZodInvalidArgumentsIssue as ZodInvalidArgumentsIssue,
-    external_d_ZodInvalidReturnTypeIssue as ZodInvalidReturnTypeIssue,
-    external_d_ZodInvalidDateIssue as ZodInvalidDateIssue,
-    external_d_StringValidation as StringValidation,
-    external_d_ZodInvalidStringIssue as ZodInvalidStringIssue,
-    external_d_ZodTooSmallIssue as ZodTooSmallIssue,
-    external_d_ZodTooBigIssue as ZodTooBigIssue,
-    external_d_ZodInvalidIntersectionTypesIssue as ZodInvalidIntersectionTypesIssue,
-    external_d_ZodNotMultipleOfIssue as ZodNotMultipleOfIssue,
-    external_d_ZodCustomIssue as ZodCustomIssue,
-    external_d_DenormalizedError as DenormalizedError,
-    external_d_ZodIssueOptionalMessage as ZodIssueOptionalMessage,
-    external_d_ZodIssue as ZodIssue,
-    external_d_quotelessJson as quotelessJson,
-    external_d_ZodFormattedError as ZodFormattedError,
-    external_d_ZodError as ZodError,
-    external_d_IssueData as IssueData,
-    external_d_MakeErrorData as MakeErrorData,
-    external_d_ZodErrorMap as ZodErrorMap,
-    external_d_defaultErrorMap as defaultErrorMap,
-    external_d_overrideErrorMap as overrideErrorMap,
-    external_d_setErrorMap as setErrorMap,
+    mod_RefinementCtx as RefinementCtx,
+    mod_ZodRawShape as ZodRawShape,
+    mod_ZodTypeAny as ZodTypeAny,
+    mod_TypeOf as TypeOf,
+    mod_input as input,
+    mod_output as output,
+    mod_TypeOfFlattenedError as TypeOfFlattenedError,
+    mod_TypeOfFormErrors as TypeOfFormErrors,
+    mod_CustomErrorParams as CustomErrorParams,
+    mod_ZodTypeDef as ZodTypeDef,
+    mod_SafeParseSuccess as SafeParseSuccess,
+    mod_SafeParseError as SafeParseError,
+    mod_SafeParseReturnType as SafeParseReturnType,
+    mod_ZodType as ZodType,
+    mod_ZodStringDef as ZodStringDef,
+    mod_ZodString as ZodString,
+    mod_ZodNumberDef as ZodNumberDef,
+    mod_ZodNumber as ZodNumber,
+    mod_ZodBigIntDef as ZodBigIntDef,
+    mod_ZodBigInt as ZodBigInt,
+    mod_ZodBooleanDef as ZodBooleanDef,
+    mod_ZodBoolean as ZodBoolean,
+    mod_ZodDateDef as ZodDateDef,
+    mod_ZodDate as ZodDate,
+    mod_ZodUndefinedDef as ZodUndefinedDef,
+    mod_ZodUndefined as ZodUndefined,
+    mod_ZodNullDef as ZodNullDef,
+    mod_ZodNull as ZodNull,
+    mod_ZodAnyDef as ZodAnyDef,
+    mod_ZodAny as ZodAny,
+    mod_ZodUnknownDef as ZodUnknownDef,
+    mod_ZodUnknown as ZodUnknown,
+    mod_ZodNeverDef as ZodNeverDef,
+    mod_ZodNever as ZodNever,
+    mod_ZodVoidDef as ZodVoidDef,
+    mod_ZodVoid as ZodVoid,
+    mod_ZodArrayDef as ZodArrayDef,
+    mod_ArrayCardinality as ArrayCardinality,
+    mod_ZodArray as ZodArray,
+    mod_ZodNonEmptyArray as ZodNonEmptyArray,
+    mod_objectUtil as objectUtil,
+    mod_extendShape as extendShape,
+    mod_ZodObjectDef as ZodObjectDef,
+    mod_baseObjectOutputType as baseObjectOutputType,
+    mod_objectOutputType as objectOutputType,
+    mod_baseObjectInputType as baseObjectInputType,
+    mod_objectInputType as objectInputType,
+    mod_SomeZodObject as SomeZodObject,
+    mod_ZodObject as ZodObject,
+    mod_AnyZodObject as AnyZodObject,
+    mod_ZodUnionDef as ZodUnionDef,
+    mod_ZodUnion as ZodUnion,
+    mod_ZodDiscriminatedUnionOption as ZodDiscriminatedUnionOption,
+    mod_ZodDiscriminatedUnionDef as ZodDiscriminatedUnionDef,
+    mod_ZodDiscriminatedUnion as ZodDiscriminatedUnion,
+    mod_ZodIntersectionDef as ZodIntersectionDef,
+    mod_ZodIntersection as ZodIntersection,
+    mod_ZodTupleItems as ZodTupleItems,
+    mod_AssertArray as AssertArray,
+    mod_OutputTypeOfTuple as OutputTypeOfTuple,
+    mod_OutputTypeOfTupleWithRest as OutputTypeOfTupleWithRest,
+    mod_InputTypeOfTuple as InputTypeOfTuple,
+    mod_InputTypeOfTupleWithRest as InputTypeOfTupleWithRest,
+    mod_ZodTupleDef as ZodTupleDef,
+    mod_ZodTuple as ZodTuple,
+    mod_ZodRecordDef as ZodRecordDef,
+    mod_ZodRecord as ZodRecord,
+    mod_ZodMapDef as ZodMapDef,
+    mod_ZodMap as ZodMap,
+    mod_ZodSetDef as ZodSetDef,
+    mod_ZodSet as ZodSet,
+    mod_ZodFunctionDef as ZodFunctionDef,
+    mod_OuterTypeOfFunction as OuterTypeOfFunction,
+    mod_InnerTypeOfFunction as InnerTypeOfFunction,
+    mod_ZodFunction as ZodFunction,
+    mod_ZodLazyDef as ZodLazyDef,
+    mod_ZodLazy as ZodLazy,
+    mod_ZodLiteralDef as ZodLiteralDef,
+    mod_ZodLiteral as ZodLiteral,
+    mod_ArrayKeys as ArrayKeys,
+    mod_Indices as Indices,
+    mod_ZodEnumDef as ZodEnumDef,
+    mod_ZodEnum as ZodEnum,
+    mod_ZodNativeEnumDef as ZodNativeEnumDef,
+    mod_ZodNativeEnum as ZodNativeEnum,
+    mod_ZodPromiseDef as ZodPromiseDef,
+    mod_ZodPromise as ZodPromise,
+    mod_Refinement as Refinement,
+    mod_SuperRefinement as SuperRefinement,
+    mod_RefinementEffect as RefinementEffect,
+    mod_TransformEffect as TransformEffect,
+    mod_PreprocessEffect as PreprocessEffect,
+    mod_Effect as Effect,
+    mod_ZodEffectsDef as ZodEffectsDef,
+    mod_ZodEffects as ZodEffects,
+    mod_ZodOptionalDef as ZodOptionalDef,
+    mod_ZodOptionalType as ZodOptionalType,
+    mod_ZodOptional as ZodOptional,
+    mod_ZodNullableDef as ZodNullableDef,
+    mod_ZodNullableType as ZodNullableType,
+    mod_ZodNullable as ZodNullable,
+    mod_ZodDefaultDef as ZodDefaultDef,
+    mod_ZodDefault as ZodDefault,
+    mod_ZodNaNDef as ZodNaNDef,
+    mod_ZodNaN as ZodNaN,
+    mod_custom as custom,
+    mod_late as late,
+    mod_ZodFirstPartyTypeKind as ZodFirstPartyTypeKind,
+    mod_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes,
+    mod_ZodIssueCode as ZodIssueCode,
+    mod_ZodIssueBase as ZodIssueBase,
+    mod_ZodInvalidTypeIssue as ZodInvalidTypeIssue,
+    mod_ZodUnrecognizedKeysIssue as ZodUnrecognizedKeysIssue,
+    mod_ZodInvalidUnionIssue as ZodInvalidUnionIssue,
+    mod_ZodInvalidUnionDiscriminatorIssue as ZodInvalidUnionDiscriminatorIssue,
+    mod_ZodInvalidEnumValueIssue as ZodInvalidEnumValueIssue,
+    mod_ZodInvalidArgumentsIssue as ZodInvalidArgumentsIssue,
+    mod_ZodInvalidReturnTypeIssue as ZodInvalidReturnTypeIssue,
+    mod_ZodInvalidDateIssue as ZodInvalidDateIssue,
+    mod_StringValidation as StringValidation,
+    mod_ZodInvalidStringIssue as ZodInvalidStringIssue,
+    mod_ZodTooSmallIssue as ZodTooSmallIssue,
+    mod_ZodTooBigIssue as ZodTooBigIssue,
+    mod_ZodInvalidIntersectionTypesIssue as ZodInvalidIntersectionTypesIssue,
+    mod_ZodNotMultipleOfIssue as ZodNotMultipleOfIssue,
+    mod_ZodCustomIssue as ZodCustomIssue,
+    mod_DenormalizedError as DenormalizedError,
+    mod_ZodIssueOptionalMessage as ZodIssueOptionalMessage,
+    mod_ZodIssue as ZodIssue,
+    mod_quotelessJson as quotelessJson,
+    mod_ZodFormattedError as ZodFormattedError,
+    mod_ZodError as ZodError,
+    mod_IssueData as IssueData,
+    mod_MakeErrorData as MakeErrorData,
+    mod_ZodErrorMap as ZodErrorMap,
+    mod_defaultErrorMap as defaultErrorMap,
+    mod_overrideErrorMap as overrideErrorMap,
+    mod_setErrorMap as setErrorMap,
   };
 }
 
 declare namespace schema {
   export {
-    external_d as define,
+    mod as define,
   };
 }
 
@@ -5283,6 +5404,19 @@ declare namespace toml {
   };
 }
 
+interface CreateOptions {
+    port: number;
+    authToken: string;
+}
+declare function create(options: CreateOptions): Promise<string>;
+
+declare const tunnel_create: typeof create;
+declare namespace tunnel {
+  export {
+    tunnel_create as create,
+  };
+}
+
 /**
  * JSON Schema
  *
@@ -6178,7 +6312,7 @@ declare enum JSONSchemaContentEncoding {
   XToken = 'x-token'
 }
 
-interface Options<T> {
+interface Options<T extends Record<string, any>> {
     /**
     Config used if there are no existing config.
 
@@ -6384,7 +6518,7 @@ interface Options<T> {
     */
     readonly configFileMode?: number;
 }
-declare type Migrations<T> = Record<string, (store: Conf<T>) => void>;
+declare type Migrations<T extends Record<string, any>> = Record<string, (store: Conf<T>) => void>;
 declare type Schema<T> = {
     [Property in keyof T]: ValueSchema;
 };
@@ -6595,6 +6729,21 @@ interface CreateAppQuerySchema {
     };
 }
 
+declare const UpdateURLsQuery: string;
+interface UpdateURLsQueryVariables {
+    apiKey: string;
+    appUrl: string;
+    redir: string[];
+}
+interface UpdateURLsQuerySchema {
+    appUpdate: {
+        userErrors: {
+            field: string[];
+            message: string;
+        }[];
+    };
+}
+
 declare const index_FindOrganizationQuery: typeof FindOrganizationQuery;
 type index_FindOrganizationQuerySchema = FindOrganizationQuerySchema;
 type index_AllOrganizationsQuerySchema = AllOrganizationsQuerySchema;
@@ -6602,6 +6751,9 @@ declare const index_AllOrganizationsQuery: typeof AllOrganizationsQuery;
 declare const index_CreateAppQuery: typeof CreateAppQuery;
 type index_CreateAppQueryVariables = CreateAppQueryVariables;
 type index_CreateAppQuerySchema = CreateAppQuerySchema;
+declare const index_UpdateURLsQuery: typeof UpdateURLsQuery;
+type index_UpdateURLsQueryVariables = UpdateURLsQueryVariables;
+type index_UpdateURLsQuerySchema = UpdateURLsQuerySchema;
 declare namespace index {
   export {
     index_FindOrganizationQuery as FindOrganizationQuery,
@@ -6611,6 +6763,9 @@ declare namespace index {
     index_CreateAppQuery as CreateAppQuery,
     index_CreateAppQueryVariables as CreateAppQueryVariables,
     index_CreateAppQuerySchema as CreateAppQuerySchema,
+    index_UpdateURLsQuery as UpdateURLsQuery,
+    index_UpdateURLsQueryVariables as UpdateURLsQueryVariables,
+    index_UpdateURLsQuerySchema as UpdateURLsQuerySchema,
   };
 }
 
@@ -6897,5 +7052,5 @@ declare const constants: {
     };
 };
 
-export { api, checksum, constants, dependency, environment, error$1 as error, file, git, http, os, output$1 as output, path, schema, session, store, string, system, template, toml, ui, version };
+export { api, checksum, constants, dependency, environment, error$1 as error, file, git, http, os, output$1 as output, path, schema, session, store, string, system, template, toml, tunnel, ui, version };
 //# sourceMappingURL=index.d.ts.map