@opentiny/genui-sdk-vue 1.2.1 → 1.3.0-alpha.3

package/dist/chat.d.ts

@@ -1,8 +1,12 @@
 import { AIClient } from '@opentiny/tiny-robot-kit';
+import { BaseModelProvider } from '@opentiny/tiny-robot-kit';
 import { BubbleCommonProps } from '@opentiny/tiny-robot';
 import { BubbleMarkdownContentRenderer } from '@opentiny/tiny-robot';
 import { BubbleProps } from '@opentiny/tiny-robot';
 import { BubbleRoleConfig } from '@opentiny/tiny-robot';
+import { CardSchema } from '@opentiny/genui-sdk-core';
+import { ChatCompletionRequest } from '@opentiny/tiny-robot-kit';
+import { ChatCompletionResponse } from '@opentiny/tiny-robot-kit';
 import { ChatMessage } from '@opentiny/tiny-robot-kit';
 import { Component } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
@@ -12,6 +16,13 @@ import { Conversation } from '@opentiny/tiny-robot-kit';
 import { ConversationState } from '@opentiny/tiny-robot-kit';
 import { ConversationStorageStrategy } from '@opentiny/tiny-robot-kit';
 import { DefineComponent } from 'vue';
+import { IChatMessage } from '@opentiny/genui-sdk-core';
+import { IGenPromptAction } from '@opentiny/genui-sdk-core';
+import { IGenPromptComponent } from '@opentiny/genui-sdk-core';
+import { IGenPromptExample } from '@opentiny/genui-sdk-core';
+import { IGenPromptSnippet } from '@opentiny/genui-sdk-core';
+import { INotificationPayload } from '@opentiny/genui-sdk-core';
+import { IStreamData } from '@opentiny/genui-sdk-core';
 import { MessageState } from '@opentiny/tiny-robot-kit';
 import { PublicProps } from 'vue';
 import { Reactive } from 'vue';
@@ -27,6 +38,7 @@ import { VNode } from 'vue';
 declare const __VLS_component: DefineComponent<IChatProps, {
 setInputMessage: (message: string) => void;
 handleNewConversation: () => void;
+getProps: () => IChatProps;
 getConversation: () => UseConversationReturn;
 getResponseHandlers: () => IResponseHandler<IStreamData>[];
 setResponseHandlers: (handlers: IResponseHandler<IStreamData>[]) => void;
@@ -80,6 +92,32 @@ content: string;
 }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 };
 setMessageRenderer: (key: string, renderer: Component<IRendererProps>) => void;
+generating: ComputedRef<boolean>;
+lastSchemaCardId: ComputedRef<any>;
+continueChatAction: {
+name: string;
+description: string;
+execute: (params: {
+message: string;
+}, context: Record<string, any>) => void;
+parameters: {
+type: "object";
+properties: {
+message: {
+type: string;
+description: string;
+};
+};
+};
+};
+saveStateAction: {
+name: string;
+description: string;
+execute: (params: any, context: Record<string | symbol, any>) => void;
+parameters: {
+type: "null";
+};
+};
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<IChatProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
 messagesContainer: HTMLDivElement;
 }, HTMLDivElement>;
@@ -103,103 +141,8 @@ declare type __VLS_WithTemplateSlots<T, S> = T & {
     };
 };
 
-declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
-
-declare type allKeys<T> = T extends any ? keyof T : never;
-
-declare const anyType: (params?: RawCreateParams) => ZodAny;
-
-declare type AnyZodObject = ZodObject<any, any, any>;
-
-declare type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAny | null>;
-
-declare type ArrayCardinality = "many" | "atleastone";
-
-declare type ArrayKeys = keyof any[];
-
-declare type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
-
-declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
-
-declare type AssertArray<T> = T extends any[] ? T : never;
-
-declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-
-declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
-    [k in keyof Shape]: Shape[k]["_input"];
-}>;
-
-declare type baseObjectOutputType<Shape extends ZodRawShape> = {
-    [k in keyof Shape]: Shape[k]["_output"];
-};
-
-declare const bigIntType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodBigInt;
-
-declare const booleanType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodBoolean;
-
-declare const BRAND: unique symbol;
-
-declare type BRAND<T extends string | number | symbol> = {
-    [BRAND]: {
-        [k in T]: true;
-    };
-};
-
-declare type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
-    readonly [Symbol.toStringTag]: string;
-} | Date | Error | Generator | Promise<unknown> | RegExp;
-
-declare type CardSchema = z.infer<typeof cardSchema>;
-
-declare const cardSchema: z.ZodType<RootNode, z.ZodTypeDef, RootNode>;
-
-declare type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
-    [k: string]: T["_input"];
-};
-
-declare type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
-    [k: string]: T["_output"];
-};
-
-declare abstract class Class {
-    constructor(..._: any[]);
-}
-
-declare const coerce: {
-    string: (typeof ZodString)["create"];
-    number: (typeof ZodNumber)["create"];
-    boolean: (typeof ZodBoolean)["create"];
-    bigint: (typeof ZodBigInt)["create"];
-    date: (typeof ZodDate)["create"];
-};
-
 export declare function createI18n(options?: I18nOptions): I18nInstance;
 
-declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
-
-declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
-
-declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams), 
-/**
- * @deprecated
- *
- * Pass `fatal` into the params object instead:
- *
- * ```ts
- * z.string().custom((val) => val.length > 5, { fatal: false })
- * ```
- *
- */
-fatal?: boolean): ZodType<T, ZodTypeDef, T>;
-
-export declare const CUSTOM_CONTEXT: unique symbol;
-
-declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
-
 /**
  * 自定义请求函数类型
  * @param url 请求地址
@@ -213,88 +156,35 @@ export declare type CustomFetch = (url: string, options: {
     signal?: AbortSignal;
 }) => Promise<Response> | Response;
 
-declare type CustomParams = CustomErrorParams & {
-    fatal?: boolean;
-};
-
-declare function datetimeRegex(args: {
-    precision?: number | null;
-    offset?: boolean;
-    local?: boolean;
-}): RegExp;
-
-declare const dateType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodDate;
+export declare class CustomModelProvider extends BaseModelProvider {
+    private getChatOptions;
+    protected responseHandlers: IResponseHandler<IStreamData>[];
+    constructor({ getChatOptions }: ICustomModelProviderOptions);
+    validateRequest(_: ChatCompletionRequest): void;
+    setResponseHandlers(handlers: IResponseHandler<IStreamData>[]): void;
+    getData(request: ChatCompletionRequest): Promise<Response>;
+    chat(_: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    chatStream(request: any, handler: {
+        onData: any;
+        onDone: any;
+        onError: any;
+    }): Promise<void>;
+    protected setupStreamContext(context: Record<string, unknown>, _request: ChatCompletionRequest): void;
+    handlerChunk(rawData: string, context: any): void;
+    handlerStart(context: any, handlers: {
+        onData: (data: IChatMessage) => void;
+        onDone: () => void;
+        onError: (error: Error) => void;
+    }): void;
+    handlerEnd(context: any): void;
+}
 
 export declare const DEFAULT_IMAGE_FEATURES: ImageFeatures;
 
-declare type DenormalizedError = {
-    [k: string]: DenormalizedError | string[];
-};
-
-declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
-
-declare type DIRTY<T> = {
-    status: "dirty";
-    value: T;
-};
-
-declare const DIRTY: <T>(value: T) => DIRTY<T>;
-
-declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
-
-declare type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
-
-declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+export declare const defaultResponseHandlers: IResponseHandler<IStreamData>[];
 
 export declare const emitter: EventEmitter;
 
-declare const EMPTY_PATH: ParsePath;
-
-declare type EnumLike = {
-    [k: string]: string | number;
-    [nu: number]: string;
-};
-
-declare const enumType: typeof createZodEnum;
-
-declare namespace enumUtil {
-    type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
-    type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
-    type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
-    type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
-    type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
-        {};
-}
-
-declare type EnumValues<T extends string = string> = readonly [T, ...T[]];
-
-declare const errorMap: ZodErrorMap;
-
-declare type ErrorMapCtx = {
-    defaultError: string;
-    data: any;
-};
-
-declare type ErrorMessages<T extends JsonSchema7TypeUnion | {
-    format: string;
-} | {
-    pattern: string;
-}, OmitProperties extends string = ""> = Partial<Omit<{
-    [key in keyof T]: string;
-}, OmitProperties | "type" | "errorMessages">>;
-
-declare namespace errorUtil {
-    type ErrMessage = string | {
-        message?: string | undefined;
-    };
-    const errToObj: (message?: ErrMessage) => {
-        message?: string | undefined;
-    };
-    const toString: (message?: ErrMessage) => string | undefined;
-}
-
 export declare class EventEmitter {
     private events;
     constructor();
@@ -329,22 +219,8 @@ declare interface FileMeta {
     base64: string;
 }
 
-declare type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
-
-declare const functionType: typeof ZodFunction.create;
-
-export declare const GENUI_CONFIG: unique symbol;
-
-export declare const GENUI_I18N: unique symbol;
-
-export declare const GENUI_RENDERER: unique symbol;
-
 export declare const GenuiChat: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 
-declare function getErrorMap(): ZodErrorMap;
-
-declare const getParsedType: (data: any) => ZodParsedType;
-
 export declare interface I18nInstance {
     locale: Ref<string>;
     messages: Readonly<Reactive<UnwrapNestedRefs<I18nMessages>>>;
@@ -383,16 +259,6 @@ export declare interface IChatConfig {
     showThinkingResult?: boolean;
 }
 
-/**
- * 单轮对话中的消息对象
- */
-declare interface IChatMessage {
-    role: 'assistant';
-    content: string;
-    messages: IMessageItem_2[];
-    [customKey: string]: any;
-}
-
 export declare interface IChatProps {
     url?: string;
     model?: string;
@@ -411,82 +277,33 @@ export declare interface IChatProps {
     customFetch?: CustomFetch;
 }
 
-/**
- * 单次流式响应中的一条 choice（与 OpenAI chat.completion.chunk 对齐）
- */
-declare interface IChatStreamChoice {
-    index: number;
-    delta?: IStreamDelta;
-    finish_reason?: string | null;
+declare interface ICustomAction extends Partial<IGenPromptAction> {
+    execute: (params: any, context: Record<string, any>) => any;
 }
 
 export declare interface ICustomActionItem extends IGenPromptAction {
-    execute: (params: any, context: Record<string, any>) => void;
+    execute: (params: any, context: Record<string, any>) => any;
 }
 
 export declare interface ICustomComponentItem extends IGenPromptComponent {
     ref: Component;
 }
 
-declare interface IFunctionInfo {
-    params: IFunctionParam[];
-    returns: Record<string, any>;
-}
-
-declare interface IFunctionParam {
-    name: string;
-    type: string;
-    defaultValue: string;
-    description: II18nText;
-}
-
-declare interface IGenPromptAction {
-    name: string;
-    description?: string;
-    parameters?: JsonSchema7Type;
-}
-
-declare interface IGenPromptComponent {
-    component: string;
-    schema: IGenPromptComponentSchema;
-    name?: string;
-    description?: string;
-}
-
-declare interface IGenPromptComponentEvent {
-    type: string;
-    functionInfo?: IFunctionInfo;
-    defaultValue?: string;
-    description: string;
-}
-
-declare interface IGenPromptComponentProperty {
-    property: string;
-    description: string;
-    type: string;
-    required?: boolean;
-    defaultValue?: any;
-    properties?: IGenPromptComponentProperty[];
-}
-
-declare interface IGenPromptComponentSchema {
-    properties?: IGenPromptComponentProperty[];
-    events?: IGenPromptComponentEvent[];
-    slots?: Record<string, any>;
-}
-
-declare interface IGenPromptExample {
-    id?: string;
-    name: string;
-    description?: string;
-    schema: CardSchema;
+/** 与 {@link chat} 入参对齐的选项；由调用方在每次请求前给出当前值（与 props / 状态同步） */
+export declare interface ICustomModelChatOptions {
+    url: string;
+    model: string;
+    temperature: number;
+    chatConfig: IChatConfig;
+    customComponents: ICustomComponentItem[];
+    customSnippets: IGenPromptSnippet[];
+    customExamples: IGenPromptExample[];
+    customActions: ICustomActionItem[];
+    customFetch?: CustomFetch;
 }
 
-declare type IGenPromptSnippet = NodeSchema;
-
-declare interface II18nText {
-    zh_CN: string;
-    [key: string]: string;
+export declare interface ICustomModelProviderOptions {
+    getChatOptions: () => ICustomModelChatOptions;
 }
 
 export declare interface ImageFeatures {
@@ -496,11 +313,6 @@ export declare interface ImageFeatures {
     supportedFileTypes: string[];
 }
 
-declare interface IMarkdownMessageItem {
-    type: 'markdown';
-    content: string;
-}
-
 export declare interface IMessage {
     role: 'user' | 'assistant';
     content: string;
@@ -513,11 +325,6 @@ export declare interface IMessageItem {
     [customKey: string]: any;
 }
 
-/**
- * 消息项类型
- */
-declare type IMessageItem_2 = IMarkdownMessageItem | ISchemaCardMessageItem | IToolMessageItem | IReasoningMessageItem;
-
 export declare class IndexedDBStrategy implements ConversationStorageStrategy {
     private dbName;
     private storeName;
@@ -529,14 +336,6 @@ export declare class IndexedDBStrategy implements ConversationStorageStrategy {
     loadConversations(): Promise<Conversation[]>;
 }
 
-declare type Indices<T> = Exclude<keyof T, ArrayKeys>;
-
-declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
-
-declare type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
-
-declare type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
-
 /**
  * 通知事件发射器类型，专门用于处理 'notification' 事件
  */
@@ -547,48 +346,6 @@ export declare interface INotificationEventEmitter {
     once(eventName: 'notification', callback: (payload: INotificationPayload) => void): void;
 }
 
-/**
- * 流式通知事件负载，包含事件类型、增量数据和完整的消息对象
- */
-declare type INotificationPayload = {
-    type: 'markdown' | 'schema-card' | 'done';
-    delta: IStreamDelta;
-    chatMessage: IChatMessage;
-} | {
-    type: 'tool';
-    delta: IStreamDelta;
-    chatMessage: IChatMessage;
-    toolCallData: IMessageItem_2 & {
-        type: 'tool';
-    };
-};
-
-declare type input<T extends ZodType<any, any, any>> = T["_input"];
-
-declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
-}>;
-
-declare type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
-
-declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
-
-declare const intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
-
-declare type INVALID = {
-    status: "aborted";
-};
-
-declare const INVALID: INVALID;
-
-declare type IpVersion = "v4" | "v6";
-
-declare interface IReasoningMessageItem {
-    type: 'reasoning';
-    content: string;
-    thinking?: boolean;
-}
-
 declare interface IRendererProps {
     content: string | {
         [prop: string]: any;
@@ -596,7 +353,7 @@ declare interface IRendererProps {
     generating?: boolean;
     isJsonComplete?: boolean;
     customComponents?: Record<string, Component>;
-    customActions?: any;
+    customActions?: Record<string, ICustomAction>;
     requiredCompleteFieldSelectors?: string[];
     id?: string;
     state?: Record<string, any>;
@@ -613,7 +370,7 @@ declare interface IRendererSlotsProps {
     isFinished: boolean;
 }
 
-declare interface IResponseHandler<T> {
+export declare interface IResponseHandler<T> {
     name: string;
     match: (data: T, context: any) => boolean;
     handler: (data: T, context: any) => boolean;
@@ -631,299 +388,14 @@ export declare interface IRolesConfig {
     assistant: Partial<BubbleRoleConfig>;
 }
 
-declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
-
-declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
-
-declare interface ISchemaCardMessageItem {
-    type: 'schema-card';
-    content: string;
-    id?: string;
-    state?: Record<string, any>;
-}
-
-declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
-
 declare type ISlotProps = any;
 
-declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
-    path?: (string | number)[];
-    fatal?: boolean | undefined;
-};
-
-/**
- * 单次 SSE data 行解析后的完整负载（含 id、model、choices 等顶层字段）
- */
-declare interface IStreamData {
-    id?: string;
-    object?: string;
-    model?: string;
-    type?: string;
-    created?: number;
-    choices?: IChatStreamChoice[];
-    usage?: {
-        prompt_tokens?: number;
-        completion_tokens?: number;
-        total_tokens?: number;
-    };
-}
-
-/**
- * 流式响应的增量数据
- */
-declare interface IStreamDelta {
-    reasoning_content?: string;
-    content?: string;
-    tool_calls?: Array<{
-        id: string;
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }>;
-    tool_calls_result?: Array<{
-        id: string;
-        function: {
-            arguments: any;
-            result: any;
-        };
-    }>;
-}
-
-declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
-
 export declare interface IThinkComponentProps {
     emitter: INotificationEventEmitter;
     message: IMessage;
     showThinkingResult: boolean;
 }
 
-declare interface IToolMessageItem {
-    type: 'tool';
-    name: string;
-    formatPretty?: boolean;
-    status: 'running' | 'success' | 'failed' | 'cancelled';
-    content: string;
-    id?: string;
-}
-
-declare type JSFunction = {
-    type: 'JSFunction';
-    value: string;
-    params?: string[];
-};
-
-declare type JsonSchema7AllOfType = {
-    allOf: JsonSchema7Type[];
-    unevaluatedProperties?: boolean;
-};
-
-declare type JsonSchema7AnyOfType = {
-    anyOf: JsonSchema7Type[];
-};
-
-declare type JsonSchema7AnyType = {
-    $ref?: string;
-};
-
-declare type JsonSchema7ArrayType = {
-    type: "array";
-    items?: JsonSchema7Type;
-    minItems?: number;
-    maxItems?: number;
-    errorMessages?: ErrorMessages<JsonSchema7ArrayType, "items">;
-};
-
-declare type JsonSchema7BigintType = {
-    type: "integer";
-    format: "int64";
-    minimum?: BigInt;
-    exclusiveMinimum?: BigInt;
-    maximum?: BigInt;
-    exclusiveMaximum?: BigInt;
-    multipleOf?: BigInt;
-    errorMessage?: ErrorMessages<JsonSchema7BigintType>;
-};
-
-declare type JsonSchema7BooleanType = {
-    type: "boolean";
-};
-
-declare type JsonSchema7DateType = {
-    type: "integer" | "string";
-    format: "unix-time" | "date-time" | "date";
-    minimum?: number;
-    maximum?: number;
-    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
-} | {
-    anyOf: JsonSchema7DateType[];
-};
-
-declare type JsonSchema7EnumType = {
-    type: "string";
-    enum: string[];
-};
-
-declare type JsonSchema7LiteralType = {
-    type: "string" | "number" | "integer" | "boolean";
-    const: string | number | boolean;
-} | {
-    type: "object" | "array";
-};
-
-declare type JsonSchema7MapType = {
-    type: "array";
-    maxItems: 125;
-    items: {
-        type: "array";
-        items: [JsonSchema7Type, JsonSchema7Type];
-        minItems: 2;
-        maxItems: 2;
-    };
-};
-
-declare type JsonSchema7Meta = {
-    title?: string;
-    default?: any;
-    description?: string;
-    markdownDescription?: string;
-};
-
-declare type JsonSchema7NativeEnumType = {
-    type: "string" | "number" | ["string", "number"];
-    enum: (string | number)[];
-};
-
-declare type JsonSchema7NeverType = {
-    not: JsonSchema7AnyType;
-};
-
-declare type JsonSchema7NullableType = {
-    anyOf: [JsonSchema7Type, JsonSchema7NullType];
-} | {
-    type: [string, "null"];
-};
-
-declare type JsonSchema7NullType = {
-    type: "null";
-};
-
-declare type JsonSchema7NumberType = {
-    type: "number" | "integer";
-    minimum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    exclusiveMaximum?: number;
-    multipleOf?: number;
-    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
-};
-
-declare type JsonSchema7ObjectType = {
-    type: "object";
-    properties: Record<string, JsonSchema7Type>;
-    additionalProperties?: boolean | JsonSchema7Type;
-    required?: string[];
-};
-
-declare type JsonSchema7Primitive = (typeof primitiveMappings)[keyof typeof primitiveMappings];
-
-declare type JsonSchema7PrimitiveUnionType = {
-    type: JsonSchema7Primitive | JsonSchema7Primitive[];
-} | {
-    type: JsonSchema7Primitive | JsonSchema7Primitive[];
-    enum: (string | number | bigint | boolean | null)[];
-};
-
-declare type JsonSchema7RecordPropertyNamesType = Omit<JsonSchema7StringType, "type"> | Omit<JsonSchema7EnumType, "type">;
-
-declare type JsonSchema7RecordType = {
-    type: "object";
-    additionalProperties?: JsonSchema7Type | true;
-    propertyNames?: JsonSchema7RecordPropertyNamesType;
-};
-
-declare type JsonSchema7RefType = {
-    $ref: string;
-};
-
-declare type JsonSchema7SetType = {
-    type: "array";
-    uniqueItems: true;
-    items?: JsonSchema7Type;
-    minItems?: number;
-    maxItems?: number;
-    errorMessage?: ErrorMessages<JsonSchema7SetType>;
-};
-
-declare type JsonSchema7StringType = {
-    type: "string";
-    minLength?: number;
-    maxLength?: number;
-    format?: "email" | "idn-email" | "uri" | "uuid" | "date-time" | "ipv4" | "ipv6" | "date" | "time" | "duration";
-    pattern?: string;
-    allOf?: {
-        pattern: string;
-        errorMessage?: ErrorMessages<{
-            pattern: string;
-        }>;
-    }[];
-    anyOf?: {
-        format: string;
-        errorMessage?: ErrorMessages<{
-            format: string;
-        }>;
-    }[];
-    errorMessage?: ErrorMessages<JsonSchema7StringType>;
-    contentEncoding?: string;
-};
-
-declare type JsonSchema7TupleType = {
-    type: "array";
-    minItems: number;
-    items: JsonSchema7Type[];
-} & ({
-    maxItems: number;
-} | {
-    additionalItems?: JsonSchema7Type;
-});
-
-declare type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;
-
-declare type JsonSchema7TypeUnion = JsonSchema7StringType | JsonSchema7ArrayType | JsonSchema7NumberType | JsonSchema7BigintType | JsonSchema7BooleanType | JsonSchema7DateType | JsonSchema7EnumType | JsonSchema7LiteralType | JsonSchema7NativeEnumType | JsonSchema7NullType | JsonSchema7NumberType | JsonSchema7ObjectType | JsonSchema7RecordType | JsonSchema7TupleType | JsonSchema7UnionType | JsonSchema7UndefinedType | JsonSchema7RefType | JsonSchema7NeverType | JsonSchema7MapType | JsonSchema7AnyType | JsonSchema7NullableType | JsonSchema7AllOfType | JsonSchema7UnknownType | JsonSchema7SetType;
-
-declare type JsonSchema7UndefinedType = {
-    not: JsonSchema7AnyType;
-};
-
-declare type JsonSchema7UnionType = JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType;
-
-declare type JsonSchema7UnknownType = JsonSchema7AnyType;
-
-declare type KeySchema = ZodType<string | number | symbol, any, any>;
-
-declare const late: {
-    object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
-};
-
-declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
-
-declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
-
-declare const makeIssue: (params: {
-    data: any;
-    path: (string | number)[];
-    errorMaps: ZodErrorMap[];
-    issueData: IssueData;
-}) => ZodIssue;
-
-declare type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
-
-declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
-
-declare type mergeTypes<A, B> = {
-    [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
-};
-
 export declare class MessageManager {
     messageManagerMap: Map<string, UseMessageReturn>;
     conversationState: Reactive<ConversationState>;
@@ -934,8 +406,6 @@ export declare class MessageManager {
     deleteMessageManager(id: string): void;
 }
 
-declare type Methods = Record<string, JSFunction>;
-
 export declare interface ModelCapability {
     supportImage?: ImageFeatures;
     supportFunctionCalling?: boolean;
@@ -953,279 +423,11 @@ export declare interface ModelInfo {
     features?: ModelFeatures;
 }
 
-declare const nanType: (params?: RawCreateParams) => ZodNaN;
-
-declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
-
-declare const NEVER: never;
-
-declare const neverType: (params?: RawCreateParams) => ZodNever;
-
-declare interface Node_2 {
-    id?: string;
-    componentName: string;
-    props?: Record<string, any> & {
-        columns?: {
-            slots?: Record<string, any>;
-        }[];
-    };
-    children?: Node_2[];
-    componentType?: 'Block' | 'PageStart' | 'PageSection';
-    slot?: string | Record<string, any>;
-    params?: string[];
-    loop?: Record<string, any>;
-    loopArgs?: string[];
-    condition?: boolean | Record<string, any>;
+declare interface Props {
+    templateData?: UserItem[];
+    attachments?: FileMeta[];
 }
 
-declare type NodeSchema = z.infer<typeof nodeSchema>;
-
-declare const nodeSchema: z.ZodType<Node_2, z.ZodTypeDef, Node_2>;
-
-declare type noUnrecognized<Obj extends object, Shape extends object> = {
-    [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
-};
-
-declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
-
-declare const nullType: (params?: RawCreateParams) => ZodNull;
-
-declare const numberType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodNumber;
-
-declare type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-
-declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-
-declare type ObjectPair = {
-    key: SyncParseReturnType<any>;
-    value: SyncParseReturnType<any>;
-};
-
-declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
-
-declare namespace objectUtil {
-    type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : {
-        [k in Exclude<keyof U, keyof V>]: U[k];
-    } & V;
-    type optionalKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? k : never;
-    }[keyof T];
-    type requiredKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? never : k;
-    }[keyof T];
-    type addQuestionMarks<T extends object, _O = any> = {
-        [K in requiredKeys<T>]: T[K];
-    } & {
-        [K in optionalKeys<T>]?: T[K];
-    } & {
-        [k in keyof T]?: unknown;
-    };
-    type identity<T> = T;
-    type flatten<T> = identity<{
-        [k in keyof T]: T[k];
-    }>;
-    type noNeverKeys<T> = {
-        [k in keyof T]: [T[k]] extends [never] ? never : k;
-    }[keyof T];
-    type noNever<T> = identity<{
-        [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
-    }>;
-    const mergeShapes: <U, T>(first: U, second: T) => T & U;
-    type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : {
-        [K in keyof A as K extends keyof B ? never : K]: A[K];
-    } & {
-        [K in keyof B]: B[K];
-    };
-        {};
-}
-
-declare const oboolean: () => ZodOptional<ZodBoolean>;
-
-declare type OK<T> = {
-    status: "valid";
-    value: T;
-};
-
-declare const OK: <T>(value: T) => OK<T>;
-
-declare const onumber: () => ZodOptional<ZodNumber>;
-
-declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
-
-declare const ostring: () => ZodOptional<ZodString>;
-
-declare type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
-
-declare type output<T extends ZodType<any, any, any>> = T["_output"];
-
-declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
-}>;
-
-declare type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
-
-declare interface ParseContext {
-    readonly common: {
-        readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap | undefined;
-        readonly async: boolean;
-    };
-    readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap | undefined;
-    readonly parent: ParseContext | null;
-    readonly data: any;
-    readonly parsedType: ZodParsedType;
-}
-
-declare type ParseInput = {
-    data: any;
-    path: (string | number)[];
-    parent: ParseContext;
-};
-
-declare type ParseParams = {
-    path: (string | number)[];
-    errorMap: ZodErrorMap;
-    async: boolean;
-};
-
-declare type ParsePath = ParsePathComponent[];
-
-declare type ParsePathComponent = string | number;
-
-declare interface ParseResult {
-    status: "aborted" | "dirty" | "valid";
-    data: any;
-}
-
-declare type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
-
-declare class ParseStatus {
-    value: "aborted" | "dirty" | "valid";
-    dirty(): void;
-    abort(): void;
-    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
-    static mergeObjectAsync(status: ParseStatus, pairs: {
-        key: ParseReturnType<any>;
-        value: ParseReturnType<any>;
-    }[]): Promise<SyncParseReturnType<any>>;
-    static mergeObjectSync(status: ParseStatus, pairs: {
-        key: SyncParseReturnType<any>;
-        value: SyncParseReturnType<any>;
-        alwaysSet?: boolean;
-    }[]): SyncParseReturnType;
-}
-
-declare namespace partialUtil {
-    type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
-        [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;
-    }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
-        [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
-    } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
-}
-
-declare type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
-    [k: string]: unknown;
-} : unknown;
-
-declare const pipelineType: typeof ZodPipeline.create;
-
-declare type PreprocessEffect<T> = {
-    type: "preprocess";
-    transform: (arg: T, ctx: RefinementCtx) => any;
-};
-
-declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-
-declare type Primitive = string | number | symbol | bigint | boolean | null | undefined;
-
-declare const primitiveMappings: {
-    readonly ZodString: "string";
-    readonly ZodNumber: "number";
-    readonly ZodBigInt: "integer";
-    readonly ZodBoolean: "boolean";
-    readonly ZodNull: "null";
-};
-
-declare type ProcessedCreateParams = {
-    errorMap?: ZodErrorMap | undefined;
-    description?: string | undefined;
-};
-
-declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
-
-declare interface Props {
-    templateData?: UserItem[];
-    attachments?: FileMeta[];
-}
-
-declare const quotelessJson: (obj: any) => string;
-
-declare type RawCreateParams = {
-    errorMap?: ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    message?: string | undefined;
-    description?: string | undefined;
-} | undefined;
-
-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> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
-
-declare const recordType: typeof ZodRecord.create;
-
-declare type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
-    [K in keyof T]?: ZodFormattedError<T[K]>;
-} : T extends any[] ? {
-    [k: number]: ZodFormattedError<T[number]>;
-} : T extends object ? {
-    [K in keyof T]?: ZodFormattedError<T[K]>;
-} : unknown;
-
-declare type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
-
-declare interface RefinementCtx {
-    addIssue: (arg: IssueData) => void;
-    path: (string | number)[];
-}
-
-declare type RefinementEffect<T> = {
-    type: "refinement";
-    refinement: (arg: T, ctx: RefinementCtx) => any;
-};
-
-declare type RootNode = Omit<Node_2, 'id'> & {
-    id?: string;
-    css?: string;
-    fileName?: string;
-    methods?: Methods;
-    state?: Record<string, unknown>;
-    lifeCycles?: Record<string, unknown>;
-    children?: Node_2[];
-    dataSource?: any;
-    bridge?: any;
-    inputs?: any[];
-    outputs?: any[];
-    schema?: any;
-};
-
-declare type SafeParseError<Input> = {
-    success: false;
-    error: ZodError<Input>;
-    data?: never;
-};
-
-declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-
-declare type SafeParseSuccess<Output> = {
-    success: true;
-    data: Output;
-    error?: never;
-};
-
-declare type Scalars = Primitive | Primitive[];
-
 export declare const scrollEnd: (container: Ref<HTMLElement | undefined>) => {
     scrollToBottom: () => void;
     scrollToBottomWithRetry: (maxRetries?: number, retryDelay?: number) => void;
@@ -1234,139 +436,6 @@ export declare const scrollEnd: (container: Ref<HTMLElement | undefined>) => {
     updateIsLastMessageInBottom: () => void;
 };
 
-declare function setErrorMap(map: ZodErrorMap): void;
-
-declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
-
-declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-
-/**
- * The Standard Schema interface.
- */
-declare type StandardSchemaV1<Input = unknown, Output = Input> = {
-    /**
-     * The Standard Schema properties.
-     */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-};
-
-declare namespace StandardSchemaV1 {
-    /**
-     * The Standard Schema properties interface.
-     */
-    interface Props<Input = unknown, Output = Input> {
-        /**
-         * The version number of the standard.
-         */
-        readonly version: 1;
-        /**
-         * The vendor name of the schema library.
-         */
-        readonly vendor: string;
-        /**
-         * Validates unknown input values.
-         */
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /**
-         * Inferred types associated with the schema.
-         */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /**
-     * The result interface of the validate function.
-     */
-    type Result<Output> = SuccessResult<Output> | FailureResult;
-    /**
-     * The result interface if validation succeeds.
-     */
-    interface SuccessResult<Output> {
-        /**
-         * The typed output value.
-         */
-        readonly value: Output;
-        /**
-         * The non-existent issues.
-         */
-        readonly issues?: undefined;
-    }
-    /**
-     * The result interface if validation fails.
-     */
-    interface FailureResult {
-        /**
-         * The issues of failed validation.
-         */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /**
-     * The issue interface of the failure output.
-     */
-    interface Issue {
-        /**
-         * The error message of the issue.
-         */
-        readonly message: string;
-        /**
-         * The path of the issue, if any.
-         */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /**
-     * The path segment interface of the issue.
-     */
-    interface PathSegment {
-        /**
-         * The key representing a path segment.
-         */
-        readonly key: PropertyKey;
-    }
-    /**
-     * The Standard Schema types interface.
-     */
-    interface Types<Input = unknown, Output = Input> {
-        /**
-         * The input type of the schema.
-         */
-        readonly input: Input;
-        /**
-         * The output type of the schema.
-         */
-        readonly output: Output;
-    }
-    /**
-     * Infers the input type of a Standard Schema.
-     */
-    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-    /**
-     * Infers the output type of a Standard Schema.
-     */
-    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-        {};
-}
-
-declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
-
-declare const stringType: (params?: RawCreateParams & {
-    coerce?: true;
-}) => ZodString;
-
-declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
-    includes: string;
-    position?: number | undefined;
-} | {
-    startsWith: string;
-} | {
-    endsWith: string;
-};
-
-declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-
-declare type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
-
-declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
-
-declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-
 export declare class ThinkTagWrapPattern {
     protected thinkStartFlag: string;
     protected thinkEndFlag: string;
@@ -1390,32 +459,6 @@ export declare function throttle<T extends (...args: any[]) => any>(fn: T, delay
 
 export declare const toSlotFunction: (slot: Component<ISlotProps> | ((props: ISlotProps) => VNode | VNode[]) | undefined) => (props: ISlotProps) => VNode | VNode[];
 
-declare type TransformEffect<T> = {
-    type: "transform";
-    transform: (arg: T, ctx: RefinementCtx) => any;
-};
-
-declare const tupleType: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
-
-declare type typecast<A, T> = A extends T ? A : never;
-
-declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-
-declare type typeToFlattenedError<T, U = string> = {
-    formErrors: U[];
-    fieldErrors: {
-        [P in allKeys<T>]?: U[];
-    };
-};
-
-declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
-
-declare const unionType: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
-
-declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
-
-declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
-
 /**
  * useConversation composable
  * 提供会话管理和持久化功能
@@ -1508,1375 +551,4 @@ export declare interface UseMessageReturn {
     retryRequest: (msgIndex: number) => Promise<void>;
 }
 
-declare namespace util {
-    type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
-    type isAny<T> = 0 extends 1 & T ? true : false;
-    const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
-    function assertIs<T>(_arg: T): void;
-    function assertNever(_x: never): never;
-    type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-    type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
-    type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-    type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
-    type InexactPartial<T> = {
-        [k in keyof T]?: T[k] | undefined;
-    };
-    const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
-    const getValidEnumValues: (obj: any) => any[];
-    const objectValues: (obj: any) => any[];
-    const objectKeys: ObjectConstructor["keys"];
-    const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
-    type identity<T> = objectUtil.identity<T>;
-    type flatten<T> = objectUtil.flatten<T>;
-    type noUndefined<T> = T extends undefined ? never : T;
-    const isInteger: NumberConstructor["isInteger"];
-    function joinValues<T extends any[]>(array: T, separator?: string): string;
-    const jsonStringifyReplacer: (_: string, value: any) => any;
-        {};
-}
-
-declare type Values<T extends EnumValues> = {
-    [k in T[number]]: k;
-};
-
-declare const voidType: (params?: RawCreateParams) => ZodVoid;
-
-declare type Writeable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-
-declare namespace z {
-    export {
-        setErrorMap,
-        getErrorMap,
-        errorMap as defaultErrorMap,
-        addIssueToContext,
-        makeIssue,
-        ParseParams,
-        ParsePathComponent,
-        ParsePath,
-        EMPTY_PATH,
-        ParseContext,
-        ParseInput,
-        ObjectPair,
-        ParseStatus,
-        ParseResult,
-        INVALID,
-        DIRTY,
-        OK,
-        SyncParseReturnType,
-        AsyncParseReturnType,
-        ParseReturnType,
-        isAborted,
-        isDirty,
-        isValid,
-        isAsync,
-        Primitive,
-        Scalars,
-        util,
-        objectUtil,
-        ZodParsedType,
-        getParsedType,
-        datetimeRegex,
-        custom,
-        RefinementCtx,
-        ZodRawShape,
-        ZodTypeAny,
-        TypeOf,
-        input,
-        output,
-        TypeOf as infer,
-        CustomErrorParams,
-        ZodTypeDef,
-        RawCreateParams,
-        ProcessedCreateParams,
-        SafeParseSuccess,
-        SafeParseError,
-        SafeParseReturnType,
-        ZodType,
-        IpVersion,
-        ZodStringCheck,
-        ZodStringDef,
-        ZodString,
-        ZodNumberCheck,
-        ZodNumberDef,
-        ZodNumber,
-        ZodBigIntCheck,
-        ZodBigIntDef,
-        ZodBigInt,
-        ZodBooleanDef,
-        ZodBoolean,
-        ZodDateCheck,
-        ZodDateDef,
-        ZodDate,
-        ZodSymbolDef,
-        ZodSymbol,
-        ZodUndefinedDef,
-        ZodUndefined,
-        ZodNullDef,
-        ZodNull,
-        ZodAnyDef,
-        ZodAny,
-        ZodUnknownDef,
-        ZodUnknown,
-        ZodNeverDef,
-        ZodNever,
-        ZodVoidDef,
-        ZodVoid,
-        ZodArrayDef,
-        ArrayCardinality,
-        arrayOutputType,
-        ZodArray,
-        ZodNonEmptyArray,
-        UnknownKeysParam,
-        ZodObjectDef,
-        mergeTypes,
-        objectOutputType,
-        baseObjectOutputType,
-        objectInputType,
-        baseObjectInputType,
-        CatchallOutput,
-        CatchallInput,
-        PassthroughType,
-        deoptional,
-        SomeZodObject,
-        noUnrecognized,
-        ZodObject,
-        AnyZodObject,
-        ZodUnionOptions,
-        ZodUnionDef,
-        ZodUnion,
-        ZodDiscriminatedUnionOption,
-        ZodDiscriminatedUnionDef,
-        ZodDiscriminatedUnion,
-        ZodIntersectionDef,
-        ZodIntersection,
-        ZodTupleItems,
-        AssertArray,
-        OutputTypeOfTuple,
-        OutputTypeOfTupleWithRest,
-        InputTypeOfTuple,
-        InputTypeOfTupleWithRest,
-        ZodTupleDef,
-        AnyZodTuple,
-        ZodTuple,
-        ZodRecordDef,
-        KeySchema,
-        RecordType,
-        ZodRecord,
-        ZodMapDef,
-        ZodMap,
-        ZodSetDef,
-        ZodSet,
-        ZodFunctionDef,
-        OuterTypeOfFunction,
-        InnerTypeOfFunction,
-        ZodFunction,
-        ZodLazyDef,
-        ZodLazy,
-        ZodLiteralDef,
-        ZodLiteral,
-        ArrayKeys,
-        Indices,
-        EnumValues,
-        Values,
-        ZodEnumDef,
-        Writeable,
-        FilterEnum,
-        typecast,
-        ZodEnum,
-        ZodNativeEnumDef,
-        EnumLike,
-        ZodNativeEnum,
-        ZodPromiseDef,
-        ZodPromise,
-        Refinement,
-        SuperRefinement,
-        RefinementEffect,
-        TransformEffect,
-        PreprocessEffect,
-        Effect,
-        ZodEffectsDef,
-        ZodEffects,
-        ZodEffects as ZodTransformer,
-        ZodOptionalDef,
-        ZodOptionalType,
-        ZodOptional,
-        ZodNullableDef,
-        ZodNullableType,
-        ZodNullable,
-        ZodDefaultDef,
-        ZodDefault,
-        ZodCatchDef,
-        ZodCatch,
-        ZodNaNDef,
-        ZodNaN,
-        ZodBrandedDef,
-        BRAND,
-        ZodBranded,
-        ZodPipelineDef,
-        ZodPipeline,
-        ZodReadonlyDef,
-        ZodReadonly,
-        ZodType as Schema,
-        ZodType as ZodSchema,
-        late,
-        ZodFirstPartyTypeKind,
-        ZodFirstPartySchemaTypes,
-        coerce,
-        anyType as any,
-        arrayType as array,
-        bigIntType as bigint,
-        booleanType as boolean,
-        dateType as date,
-        discriminatedUnionType as discriminatedUnion,
-        effectsType as effect,
-        enumType as enum,
-        functionType as function,
-        instanceOfType as instanceof,
-        intersectionType as intersection,
-        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,
-        oboolean,
-        onumber,
-        optionalType as optional,
-        ostring,
-        pipelineType as pipeline,
-        preprocessType as preprocess,
-        promiseType as promise,
-        recordType as record,
-        setType as set,
-        strictObjectType as strictObject,
-        stringType as string,
-        symbolType as symbol,
-        effectsType as transformer,
-        tupleType as tuple,
-        undefinedType as undefined,
-        unionType as union,
-        unknownType as unknown,
-        voidType as void,
-        NEVER,
-        inferFlattenedErrors,
-        typeToFlattenedError,
-        ZodIssueCode,
-        ZodIssueBase,
-        ZodInvalidTypeIssue,
-        ZodInvalidLiteralIssue,
-        ZodUnrecognizedKeysIssue,
-        ZodInvalidUnionIssue,
-        ZodInvalidUnionDiscriminatorIssue,
-        ZodInvalidEnumValueIssue,
-        ZodInvalidArgumentsIssue,
-        ZodInvalidReturnTypeIssue,
-        ZodInvalidDateIssue,
-        StringValidation,
-        ZodInvalidStringIssue,
-        ZodTooSmallIssue,
-        ZodTooBigIssue,
-        ZodInvalidIntersectionTypesIssue,
-        ZodNotMultipleOfIssue,
-        ZodNotFiniteIssue,
-        ZodCustomIssue,
-        DenormalizedError,
-        ZodIssueOptionalMessage,
-        ZodIssue,
-        quotelessJson,
-        ZodFormattedError,
-        inferFormattedError,
-        ZodError,
-        IssueData,
-        ErrorMapCtx,
-        ZodErrorMap
-    }
-}
-
-declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
-    _any: true;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodAny;
-}
-
-declare interface ZodAnyDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodAny;
-}
-
-declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get element(): T;
-    min(minLength: number, message?: errorUtil.ErrMessage): this;
-    max(maxLength: number, message?: errorUtil.ErrMessage): this;
-    length(len: number, message?: errorUtil.ErrMessage): this;
-    nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
-}
-
-declare interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodArray;
-    exactLength: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-    minLength: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-    maxLength: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-}
-
-declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
-    _parse(input: ParseInput): ParseReturnType<bigint>;
-    _getInvalidInput(input: ParseInput): INVALID;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodBigInt;
-    gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
-    gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
-    lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
-    _addCheck(check: ZodBigIntCheck): ZodBigInt;
-    positive(message?: errorUtil.ErrMessage): ZodBigInt;
-    negative(message?: errorUtil.ErrMessage): ZodBigInt;
-    nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;
-    nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;
-    multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    get minValue(): bigint | null;
-    get maxValue(): bigint | null;
-}
-
-declare type ZodBigIntCheck = {
-    kind: "min";
-    value: bigint;
-    inclusive: boolean;
-    message?: string | undefined;
-} | {
-    kind: "max";
-    value: bigint;
-    inclusive: boolean;
-    message?: string | undefined;
-} | {
-    kind: "multipleOf";
-    value: bigint;
-    message?: string | undefined;
-};
-
-declare interface ZodBigIntDef extends ZodTypeDef {
-    checks: ZodBigIntCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodBigInt;
-    coerce: boolean;
-}
-
-declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
-    _parse(input: ParseInput): ParseReturnType<boolean>;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodBoolean;
-}
-
-declare interface ZodBooleanDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodBoolean;
-    coerce: boolean;
-}
-
-declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    unwrap(): T;
-}
-
-declare interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodBranded;
-}
-
-declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeCatch(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-        catch: Inner["_output"] | (() => Inner["_output"]);
-    }) => ZodCatch<Inner>;
-}
-
-declare interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    catchValue: (ctx: {
-        error: ZodError;
-        input: unknown;
-    }) => T["_input"];
-    typeName: ZodFirstPartyTypeKind.ZodCatch;
-}
-
-declare interface ZodCustomIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.custom;
-    params?: {
-        [k: string]: any;
-    };
-}
-
-declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    _addCheck(check: ZodDateCheck): ZodDate;
-    min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
-    max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
-    get minDate(): Date | null;
-    get maxDate(): Date | null;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodDate;
-}
-
-declare type ZodDateCheck = {
-    kind: "min";
-    value: number;
-    message?: string | undefined;
-} | {
-    kind: "max";
-    value: number;
-    message?: string | undefined;
-};
-
-declare interface ZodDateDef extends ZodTypeDef {
-    checks: ZodDateCheck[];
-    coerce: boolean;
-    typeName: ZodFirstPartyTypeKind.ZodDate;
-}
-
-declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeDefault(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
-    }) => ZodDefault<Inner>;
-}
-
-declare interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    defaultValue: () => util.noUndefined<T["_input"]>;
-    typeName: ZodFirstPartyTypeKind.ZodDefault;
-}
-
-declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get discriminator(): Discriminator;
-    get options(): Options;
-    get optionsMap(): Map<Primitive, ZodDiscriminatedUnionOption<any>>;
-    /**
-     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
-     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
-     * have a different value for each object in the union.
-     * @param discriminator the name of the discriminator property
-     * @param types an array of object schemas
-     * @param params
-     */
-    static create<Discriminator extends string, Types extends readonly [
-    ZodDiscriminatedUnionOption<Discriminator>,
-    ...ZodDiscriminatedUnionOption<Discriminator>[]
-    ]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
-}
-
-declare interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
-    discriminator: Discriminator;
-    options: Options;
-    optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
-    typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
-}
-
-declare type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
-    [key in Discriminator]: ZodTypeAny;
-} & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-
-declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
-    innerType(): T;
-    sourceType(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-}
-
-declare interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    schema: T;
-    typeName: ZodFirstPartyTypeKind.ZodEffects;
-    effect: Effect<any>;
-}
-
-declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-    _cache: Set<T[number]> | undefined;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get options(): T;
-    get enum(): Values<T>;
-    get Values(): Values<T>;
-    get Enum(): Values<T>;
-    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
-    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
-    static create: typeof createZodEnum;
-}
-
-declare interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
-    values: T;
-    typeName: ZodFirstPartyTypeKind.ZodEnum;
-}
-
-declare class ZodError<T = any> extends Error {
-    issues: ZodIssue[];
-    get errors(): ZodIssue[];
-    constructor(issues: ZodIssue[]);
-    format(): ZodFormattedError<T>;
-    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
-    static create: (issues: ZodIssue[]) => ZodError<any>;
-    static assert(value: unknown): asserts value is ZodError;
-    toString(): string;
-    get message(): string;
-    get isEmpty(): boolean;
-    addIssue: (sub: ZodIssue) => void;
-    addIssues: (subs?: ZodIssue[]) => void;
-    flatten(): typeToFlattenedError<T>;
-    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
-    get formErrors(): typeToFlattenedError<T, string>;
-}
-
-declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
-    message: string;
-};
-
-declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
-
-declare enum ZodFirstPartyTypeKind {
-    ZodString = "ZodString",
-    ZodNumber = "ZodNumber",
-    ZodNaN = "ZodNaN",
-    ZodBigInt = "ZodBigInt",
-    ZodBoolean = "ZodBoolean",
-    ZodDate = "ZodDate",
-    ZodSymbol = "ZodSymbol",
-    ZodUndefined = "ZodUndefined",
-    ZodNull = "ZodNull",
-    ZodAny = "ZodAny",
-    ZodUnknown = "ZodUnknown",
-    ZodNever = "ZodNever",
-    ZodVoid = "ZodVoid",
-    ZodArray = "ZodArray",
-    ZodObject = "ZodObject",
-    ZodUnion = "ZodUnion",
-    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
-    ZodIntersection = "ZodIntersection",
-    ZodTuple = "ZodTuple",
-    ZodRecord = "ZodRecord",
-    ZodMap = "ZodMap",
-    ZodSet = "ZodSet",
-    ZodFunction = "ZodFunction",
-    ZodLazy = "ZodLazy",
-    ZodLiteral = "ZodLiteral",
-    ZodEnum = "ZodEnum",
-    ZodEffects = "ZodEffects",
-    ZodNativeEnum = "ZodNativeEnum",
-    ZodOptional = "ZodOptional",
-    ZodNullable = "ZodNullable",
-    ZodDefault = "ZodDefault",
-    ZodCatch = "ZodCatch",
-    ZodPromise = "ZodPromise",
-    ZodBranded = "ZodBranded",
-    ZodPipeline = "ZodPipeline",
-    ZodReadonly = "ZodReadonly"
-}
-
-declare type ZodFormattedError<T, U = string> = {
-    _errors: U[];
-} & recursiveZodFormattedError<NonNullable<T>>;
-
-declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    parameters(): Args;
-    returnType(): Returns;
-    args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
-    returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
-    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
-    strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
-    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
-    static create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;
-    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
-    static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
-    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
-}
-
-declare interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    args: Args;
-    returns: Returns;
-    typeName: ZodFirstPartyTypeKind.ZodFunction;
-}
-
-declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
-}
-
-declare interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    left: T;
-    right: U;
-    typeName: ZodFirstPartyTypeKind.ZodIntersection;
-}
-
-declare interface ZodInvalidArgumentsIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_arguments;
-    argumentsError: ZodError;
-}
-
-declare interface ZodInvalidDateIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_date;
-}
-
-declare interface ZodInvalidEnumValueIssue extends ZodIssueBase {
-    received: string | number;
-    code: typeof ZodIssueCode.invalid_enum_value;
-    options: (string | number)[];
-}
-
-declare interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_intersection_types;
-}
-
-declare interface ZodInvalidLiteralIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_literal;
-    expected: unknown;
-    received: unknown;
-}
-
-declare interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_return_type;
-    returnTypeError: ZodError;
-}
-
-declare interface ZodInvalidStringIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_string;
-    validation: StringValidation;
-}
-
-declare interface ZodInvalidTypeIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_type;
-    expected: ZodParsedType;
-    received: ZodParsedType;
-}
-
-declare interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_union_discriminator;
-    options: Primitive[];
-}
-
-declare interface ZodInvalidUnionIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_union;
-    unionErrors: ZodError[];
-}
-
-declare type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean | undefined;
-    message: string;
-};
-
-declare type ZodIssueBase = {
-    path: (string | number)[];
-    message?: string | undefined;
-};
-
-declare const ZodIssueCode: {
-    invalid_type: "invalid_type";
-    invalid_literal: "invalid_literal";
-    custom: "custom";
-    invalid_union: "invalid_union";
-    invalid_union_discriminator: "invalid_union_discriminator";
-    invalid_enum_value: "invalid_enum_value";
-    unrecognized_keys: "unrecognized_keys";
-    invalid_arguments: "invalid_arguments";
-    invalid_return_type: "invalid_return_type";
-    invalid_date: "invalid_date";
-    invalid_string: "invalid_string";
-    too_small: "too_small";
-    too_big: "too_big";
-    invalid_intersection_types: "invalid_intersection_types";
-    not_multiple_of: "not_multiple_of";
-    not_finite: "not_finite";
-};
-
-declare type ZodIssueCode = keyof typeof ZodIssueCode;
-
-declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
-
-declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
-    get schema(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
-}
-
-declare interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    getter: () => T;
-    typeName: ZodFirstPartyTypeKind.ZodLazy;
-}
-
-declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get value(): T;
-    static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
-}
-
-declare interface ZodLiteralDef<T = any> extends ZodTypeDef {
-    value: T;
-    typeName: ZodFirstPartyTypeKind.ZodLiteral;
-}
-
-declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
-    get keySchema(): Key;
-    get valueSchema(): Value;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
-}
-
-declare interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    valueType: Value;
-    keyType: Key;
-    typeName: ZodFirstPartyTypeKind.ZodMap;
-}
-
-declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    static create: (params?: RawCreateParams) => ZodNaN;
-}
-
-declare interface ZodNaNDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodNaN;
-}
-
-declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
-    _cache: Set<T[keyof T]> | undefined;
-    _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
-    get enum(): T;
-    static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
-}
-
-declare interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
-    values: T;
-    typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
-}
-
-declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodNever;
-}
-
-declare interface ZodNeverDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodNever;
-}
-
-declare type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
-
-declare interface ZodNotFiniteIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.not_finite;
-}
-
-declare interface ZodNotMultipleOfIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.not_multiple_of;
-    multipleOf: number | bigint;
-}
-
-declare class ZodNull extends ZodType<null, ZodNullDef, null> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodNull;
-}
-
-declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    unwrap(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
-}
-
-declare interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodNullable;
-}
-
-declare type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
-
-declare interface ZodNullDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodNull;
-}
-
-declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
-    _parse(input: ParseInput): ParseReturnType<number>;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodNumber;
-    gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-    gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-    lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
-    _addCheck(check: ZodNumberCheck): ZodNumber;
-    int(message?: errorUtil.ErrMessage): ZodNumber;
-    positive(message?: errorUtil.ErrMessage): ZodNumber;
-    negative(message?: errorUtil.ErrMessage): ZodNumber;
-    nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
-    nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
-    multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-    finite(message?: errorUtil.ErrMessage): ZodNumber;
-    safe(message?: errorUtil.ErrMessage): ZodNumber;
-    get minValue(): number | null;
-    get maxValue(): number | null;
-    get isInt(): boolean;
-    get isFinite(): boolean;
-}
-
-declare type ZodNumberCheck = {
-    kind: "min";
-    value: number;
-    inclusive: boolean;
-    message?: string | undefined;
-} | {
-    kind: "max";
-    value: number;
-    inclusive: boolean;
-    message?: string | undefined;
-} | {
-    kind: "int";
-    message?: string | undefined;
-} | {
-    kind: "multipleOf";
-    value: number;
-    message?: string | undefined;
-} | {
-    kind: "finite";
-    message?: string | undefined;
-};
-
-declare interface ZodNumberDef extends ZodTypeDef {
-    checks: ZodNumberCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodNumber;
-    coerce: boolean;
-}
-
-declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
-    private _cached;
-    _getCached(): {
-        shape: T;
-        keys: string[];
-    };
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get shape(): T;
-    strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
-    strip(): ZodObject<T, "strip", Catchall>;
-    passthrough(): ZodObject<T, "passthrough", Catchall>;
-    /**
-     * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
-     * If you want to pass through unknown properties, use `.passthrough()` instead.
-     */
-    nonstrict: () => ZodObject<T, "passthrough", Catchall>;
-    extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-    /**
-     * @deprecated Use `.extend` instead
-     *  */
-    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-    /**
-     * Prior to zod@1.0.12 there was a bug in the
-     * inferred type of merged objects. Please
-     * upgrade if you are experiencing issues.
-     */
-    merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
-    setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {
-        [k in Key]: Schema;
-    }, UnknownKeys, Catchall>;
-    catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-    pick<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-    omit<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
-    /**
-     * @deprecated
-     */
-    deepPartial(): partialUtil.DeepPartial<this>;
-    partial(): ZodObject<{
-        [k in keyof T]: ZodOptional<T[k]>;
-    }, UnknownKeys, Catchall>;
-    partial<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
-        [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
-    }>, UnknownKeys, Catchall>;
-    required(): ZodObject<{
-        [k in keyof T]: deoptional<T[k]>;
-    }, UnknownKeys, Catchall>;
-    required<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
-        [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
-    }>, UnknownKeys, Catchall>;
-    keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
-    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
-    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
-}
-
-declare interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodObject;
-    shape: () => T;
-    catchall: Catchall;
-    unknownKeys: UnknownKeys;
-}
-
-declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    unwrap(): T;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
-}
-
-declare interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodOptional;
-}
-
-declare type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
-
-declare const ZodParsedType: {
-    string: "string";
-    nan: "nan";
-    number: "number";
-    integer: "integer";
-    float: "float";
-    boolean: "boolean";
-    date: "date";
-    bigint: "bigint";
-    symbol: "symbol";
-    function: "function";
-    undefined: "undefined";
-    null: "null";
-    array: "array";
-    object: "object";
-    unknown: "unknown";
-    promise: "promise";
-    void: "void";
-    never: "never";
-    map: "map";
-    set: "set";
-};
-
-declare type ZodParsedType = keyof typeof ZodParsedType;
-
-declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
-}
-
-declare interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
-    in: A;
-    out: B;
-    typeName: ZodFirstPartyTypeKind.ZodPipeline;
-}
-
-declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
-    unwrap(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
-}
-
-declare interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodPromise;
-}
-
-declare type ZodRawShape = {
-    [k: string]: ZodTypeAny;
-};
-
-declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
-    unwrap(): T;
-}
-
-declare interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodReadonly;
-}
-
-declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
-    get keySchema(): Key;
-    get valueSchema(): Value;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get element(): Value;
-    static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
-    static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
-}
-
-declare interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    valueType: Value;
-    keyType: Key;
-    typeName: ZodFirstPartyTypeKind.ZodRecord;
-}
-
-declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    min(minSize: number, message?: errorUtil.ErrMessage): this;
-    max(maxSize: number, message?: errorUtil.ErrMessage): this;
-    size(size: number, message?: errorUtil.ErrMessage): this;
-    nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
-    static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
-}
-
-declare interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    valueType: Value;
-    typeName: ZodFirstPartyTypeKind.ZodSet;
-    minSize: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-    maxSize: {
-        value: number;
-        message?: string | undefined;
-    } | null;
-}
-
-declare class ZodString extends ZodType<string, ZodStringDef, string> {
-    _parse(input: ParseInput): ParseReturnType<string>;
-    protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
-    _addCheck(check: ZodStringCheck): ZodString;
-    email(message?: errorUtil.ErrMessage): ZodString;
-    url(message?: errorUtil.ErrMessage): ZodString;
-    emoji(message?: errorUtil.ErrMessage): ZodString;
-    uuid(message?: errorUtil.ErrMessage): ZodString;
-    nanoid(message?: errorUtil.ErrMessage): ZodString;
-    cuid(message?: errorUtil.ErrMessage): ZodString;
-    cuid2(message?: errorUtil.ErrMessage): ZodString;
-    ulid(message?: errorUtil.ErrMessage): ZodString;
-    base64(message?: errorUtil.ErrMessage): ZodString;
-    base64url(message?: errorUtil.ErrMessage): ZodString;
-    jwt(options?: {
-        alg?: string;
-        message?: string | undefined;
-    }): ZodString;
-    ip(options?: string | {
-        version?: IpVersion;
-        message?: string | undefined;
-    }): ZodString;
-    cidr(options?: string | {
-        version?: IpVersion;
-        message?: string | undefined;
-    }): ZodString;
-    datetime(options?: string | {
-        message?: string | undefined;
-        precision?: number | null;
-        offset?: boolean;
-        local?: boolean;
-    }): ZodString;
-    date(message?: string): ZodString;
-    time(options?: string | {
-        message?: string | undefined;
-        precision?: number | null;
-    }): ZodString;
-    duration(message?: errorUtil.ErrMessage): ZodString;
-    regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
-    includes(value: string, options?: {
-        message?: string;
-        position?: number;
-    }): ZodString;
-    startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
-    endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
-    min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
-    max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
-    length(len: number, message?: errorUtil.ErrMessage): ZodString;
-    /**
-     * Equivalent to `.min(1)`
-     */
-    nonempty(message?: errorUtil.ErrMessage): ZodString;
-    trim(): ZodString;
-    toLowerCase(): ZodString;
-    toUpperCase(): ZodString;
-    get isDatetime(): boolean;
-    get isDate(): boolean;
-    get isTime(): boolean;
-    get isDuration(): boolean;
-    get isEmail(): boolean;
-    get isURL(): boolean;
-    get isEmoji(): boolean;
-    get isUUID(): boolean;
-    get isNANOID(): boolean;
-    get isCUID(): boolean;
-    get isCUID2(): boolean;
-    get isULID(): boolean;
-    get isIP(): boolean;
-    get isCIDR(): boolean;
-    get isBase64(): boolean;
-    get isBase64url(): boolean;
-    get minLength(): number | null;
-    get maxLength(): number | null;
-    static create: (params?: RawCreateParams & {
-        coerce?: true;
-    }) => ZodString;
-}
-
-declare type ZodStringCheck = {
-    kind: "min";
-    value: number;
-    message?: string | undefined;
-} | {
-    kind: "max";
-    value: number;
-    message?: string | undefined;
-} | {
-    kind: "length";
-    value: number;
-    message?: string | undefined;
-} | {
-    kind: "email";
-    message?: string | undefined;
-} | {
-    kind: "url";
-    message?: string | undefined;
-} | {
-    kind: "emoji";
-    message?: string | undefined;
-} | {
-    kind: "uuid";
-    message?: string | undefined;
-} | {
-    kind: "nanoid";
-    message?: string | undefined;
-} | {
-    kind: "cuid";
-    message?: string | undefined;
-} | {
-    kind: "includes";
-    value: string;
-    position?: number | undefined;
-    message?: string | undefined;
-} | {
-    kind: "cuid2";
-    message?: string | undefined;
-} | {
-    kind: "ulid";
-    message?: string | undefined;
-} | {
-    kind: "startsWith";
-    value: string;
-    message?: string | undefined;
-} | {
-    kind: "endsWith";
-    value: string;
-    message?: string | undefined;
-} | {
-    kind: "regex";
-    regex: RegExp;
-    message?: string | undefined;
-} | {
-    kind: "trim";
-    message?: string | undefined;
-} | {
-    kind: "toLowerCase";
-    message?: string | undefined;
-} | {
-    kind: "toUpperCase";
-    message?: string | undefined;
-} | {
-    kind: "jwt";
-    alg?: string;
-    message?: string | undefined;
-} | {
-    kind: "datetime";
-    offset: boolean;
-    local: boolean;
-    precision: number | null;
-    message?: string | undefined;
-} | {
-    kind: "date";
-    message?: string | undefined;
-} | {
-    kind: "time";
-    precision: number | null;
-    message?: string | undefined;
-} | {
-    kind: "duration";
-    message?: string | undefined;
-} | {
-    kind: "ip";
-    version?: IpVersion | undefined;
-    message?: string | undefined;
-} | {
-    kind: "cidr";
-    version?: IpVersion | undefined;
-    message?: string | undefined;
-} | {
-    kind: "base64";
-    message?: string | undefined;
-} | {
-    kind: "base64url";
-    message?: string | undefined;
-};
-
-declare interface ZodStringDef extends ZodTypeDef {
-    checks: ZodStringCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodString;
-    coerce: boolean;
-}
-
-declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodSymbol;
-}
-
-declare interface ZodSymbolDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodSymbol;
-}
-
-declare interface ZodTooBigIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.too_big;
-    maximum: number | bigint;
-    inclusive: boolean;
-    exact?: boolean;
-    type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-
-declare interface ZodTooSmallIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.too_small;
-    minimum: number | bigint;
-    inclusive: boolean;
-    exact?: boolean;
-    type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-
-declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get items(): T;
-    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
-    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
-}
-
-declare interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
-    items: T;
-    rest: Rest;
-    typeName: ZodFirstPartyTypeKind.ZodTuple;
-}
-
-declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-
-declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
-    readonly _type: Output;
-    readonly _output: Output;
-    readonly _input: Input;
-    readonly _def: Def;
-    get description(): string | undefined;
-    "~standard": StandardSchemaV1.Props<Input, Output>;
-    abstract _parse(input: ParseInput): ParseReturnType<Output>;
-    _getType(input: ParseInput): string;
-    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
-    _processInputParams(input: ParseInput): {
-        status: ParseStatus;
-        ctx: ParseContext;
-    };
-    _parseSync(input: ParseInput): SyncParseReturnType<Output>;
-    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
-    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
-    "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
-    /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
-    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
-    refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
-    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
-    refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
-    _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
-    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
-    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
-    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
-    constructor(def: Def);
-    optional(): ZodOptional<this>;
-    nullable(): ZodNullable<this>;
-    nullish(): ZodOptional<ZodNullable<this>>;
-    array(): ZodArray<this>;
-    promise(): ZodPromise<this>;
-    or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
-    and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
-    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
-    default(def: util.noUndefined<Input>): ZodDefault<this>;
-    default(def: () => util.noUndefined<Input>): ZodDefault<this>;
-    brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
-    catch(def: Output): ZodCatch<this>;
-    catch(def: (ctx: {
-        error: ZodError;
-        input: Input;
-    }) => Output): ZodCatch<this>;
-    describe(description: string): this;
-    pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
-    readonly(): ZodReadonly<this>;
-    isOptional(): boolean;
-    isNullable(): boolean;
-}
-
-declare type ZodTypeAny = ZodType<any, any, any>;
-
-declare interface ZodTypeDef {
-    errorMap?: ZodErrorMap | undefined;
-    description?: string | undefined;
-}
-
-declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    params?: RawCreateParams;
-    static create: (params?: RawCreateParams) => ZodUndefined;
-}
-
-declare interface ZodUndefinedDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodUndefined;
-}
-
-declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get options(): T;
-    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
-}
-
-declare interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
-    options: T;
-    typeName: ZodFirstPartyTypeKind.ZodUnion;
-}
-
-declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-
-declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
-    _unknown: true;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodUnknown;
-}
-
-declare interface ZodUnknownDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodUnknown;
-}
-
-declare interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.unrecognized_keys;
-    keys: string[];
-}
-
-declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodVoid;
-}
-
-declare interface ZodVoidDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodVoid;
-}
-
 export { }