bioscode 0.1.5

package/dist/provider/provider.d.ts

@@ -0,0 +1,848 @@
+import z from "zod";
+import type { LanguageModel, ImageModel } from "ai";
+import type { ModelInfo, ProviderInfo } from "./types";
+/**
+ * Provider System
+ *
+ * Manages LLM providers and model instantiation using Vercel AI SDK.
+ * Supports multiple providers with automatic detection from environment.
+ */
+export declare namespace Provider {
+    /**
+     * Get all available providers
+     */
+    function list(): Promise<Record<string, ProviderInfo>>;
+    /**
+     * Get a specific provider
+     */
+    function get(providerId: string): Promise<ProviderInfo | undefined>;
+    /**
+     * Get a language model instance
+     */
+    function getLanguageModel(providerId: string, modelId: string): Promise<LanguageModel>;
+    /**
+     * Get an image model instance
+     */
+    function getImageModel(providerId: string, modelId: string): Promise<ImageModel>;
+    /**
+     * Get model info
+     */
+    function getModelInfo(providerId: string, modelId: string): Promise<ModelInfo>;
+    /**
+     * Parse a model string like "anthropic/claude-sonnet-4-20250514"
+     */
+    function parseModelString(model: string): {
+        providerId: string;
+        modelId: string;
+    };
+    /**
+     * Get the default model based on config or available providers
+     */
+    function getDefaultModel(): Promise<{
+        providerId: string;
+        modelId: string;
+    }>;
+    /**
+     * Get a small/fast model for auxiliary tasks like title generation
+     */
+    function getSmallModel(providerId: string): Promise<{
+        providerId: string;
+        modelId: string;
+    } | undefined>;
+    /**
+     * Clear all caches (useful for testing or config changes)
+     */
+    function clearCache(): void;
+    const ProviderNotFoundError: {
+        new (data: {
+            providerId: string;
+        }, options?: ErrorOptions): {
+            readonly name: "ProviderNotFoundError";
+            readonly data: {
+                providerId: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ProviderNotFoundError">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    providerId: string;
+                }, {
+                    providerId: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "ProviderNotFoundError";
+                data: {
+                    providerId: string;
+                };
+            }, {
+                name: "ProviderNotFoundError";
+                data: {
+                    providerId: string;
+                };
+            }>;
+            toObject(): {
+                name: "ProviderNotFoundError";
+                data: {
+                    providerId: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ProviderNotFoundError">;
+            data: z.ZodObject<{
+                providerId: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                providerId: string;
+            }, {
+                providerId: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            name: "ProviderNotFoundError";
+            data: {
+                providerId: string;
+            };
+        }, {
+            name: "ProviderNotFoundError";
+            data: {
+                providerId: string;
+            };
+        }>;
+        isInstance(input: any): input is {
+            readonly name: "ProviderNotFoundError";
+            readonly data: {
+                providerId: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ProviderNotFoundError">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    providerId: string;
+                }, {
+                    providerId: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "ProviderNotFoundError";
+                data: {
+                    providerId: string;
+                };
+            }, {
+                name: "ProviderNotFoundError";
+                data: {
+                    providerId: string;
+                };
+            }>;
+            toObject(): {
+                name: "ProviderNotFoundError";
+                data: {
+                    providerId: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                toObject(): {
+                    name: Name;
+                    data: z.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+            isInstance(input: any): input is InstanceType</*elided*/ any>;
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+            readonly Unknown: {
+                new (data: {
+                    message: string;
+                }, options?: ErrorOptions): {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                isInstance(input: any): input is {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                }, {
+                    message: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+                new (data: z.input<Data>, options?: ErrorOptions): {
+                    readonly name: Name;
+                    readonly data: z.input<Data>;
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                    toObject(): {
+                        name: Name;
+                        data: z.input<Data>;
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                isInstance(input: any): input is InstanceType</*elided*/ any>;
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            readonly Unknown: /*elided*/ any;
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    const ModelNotFoundError: {
+        new (data: {
+            providerId: string;
+            modelId: string;
+        }, options?: ErrorOptions): {
+            readonly name: "ModelNotFoundError";
+            readonly data: {
+                providerId: string;
+                modelId: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ModelNotFoundError">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                    modelId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    providerId: string;
+                    modelId: string;
+                }, {
+                    providerId: string;
+                    modelId: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "ModelNotFoundError";
+                data: {
+                    providerId: string;
+                    modelId: string;
+                };
+            }, {
+                name: "ModelNotFoundError";
+                data: {
+                    providerId: string;
+                    modelId: string;
+                };
+            }>;
+            toObject(): {
+                name: "ModelNotFoundError";
+                data: {
+                    providerId: string;
+                    modelId: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ModelNotFoundError">;
+            data: z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                providerId: string;
+                modelId: string;
+            }, {
+                providerId: string;
+                modelId: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            name: "ModelNotFoundError";
+            data: {
+                providerId: string;
+                modelId: string;
+            };
+        }, {
+            name: "ModelNotFoundError";
+            data: {
+                providerId: string;
+                modelId: string;
+            };
+        }>;
+        isInstance(input: any): input is {
+            readonly name: "ModelNotFoundError";
+            readonly data: {
+                providerId: string;
+                modelId: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ModelNotFoundError">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                    modelId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    providerId: string;
+                    modelId: string;
+                }, {
+                    providerId: string;
+                    modelId: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "ModelNotFoundError";
+                data: {
+                    providerId: string;
+                    modelId: string;
+                };
+            }, {
+                name: "ModelNotFoundError";
+                data: {
+                    providerId: string;
+                    modelId: string;
+                };
+            }>;
+            toObject(): {
+                name: "ModelNotFoundError";
+                data: {
+                    providerId: string;
+                    modelId: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                toObject(): {
+                    name: Name;
+                    data: z.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+            isInstance(input: any): input is InstanceType</*elided*/ any>;
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+            readonly Unknown: {
+                new (data: {
+                    message: string;
+                }, options?: ErrorOptions): {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                isInstance(input: any): input is {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            message: string;
+                        }, {
+                            message: string;
+                        }>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }, {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    }>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                }, {
+                    message: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }, {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            }>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                }, "strip", z.ZodTypeAny, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }, {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): {
+                new (data: z.input<Data>, options?: ErrorOptions): {
+                    readonly name: Name;
+                    readonly data: z.input<Data>;
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                    toObject(): {
+                        name: Name;
+                        data: z.input<Data>;
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }>, any> extends infer T ? { [k in keyof T]: T[k]; } : never, z.baseObjectInputType<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1]; } : never>;
+                isInstance(input: any): input is InstanceType</*elided*/ any>;
+                create<Name extends string, Data extends z.ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            readonly Unknown: /*elided*/ any;
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}