@ubundi/openclaw-cortex 1.4.0 → 1.5.1

package/node_modules/zod/v4/core/errors.d.ts

@@ -1,208 +0,0 @@
-import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
-import { $constructor } from "./core.js";
-import type { $ZodType } from "./schemas.js";
-import * as util from "./util.js";
-export interface $ZodIssueBase {
-    readonly code?: string;
-    readonly input?: unknown;
-    readonly path: PropertyKey[];
-    readonly message: string;
-}
-export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
-    readonly code: "invalid_type";
-    readonly expected: $ZodType["_zod"]["def"]["type"];
-    readonly input: Input;
-}
-export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
-    readonly code: "too_big";
-    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
-    readonly maximum: number | bigint;
-    readonly inclusive?: boolean;
-    readonly exact?: boolean;
-    readonly input: Input;
-}
-export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
-    readonly code: "too_small";
-    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
-    readonly minimum: number | bigint;
-    /** True if the allowable range includes the minimum */
-    readonly inclusive?: boolean;
-    /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
-    readonly exact?: boolean;
-    readonly input: Input;
-}
-export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
-    readonly code: "invalid_format";
-    readonly format: $ZodStringFormats | (string & {});
-    readonly pattern?: string;
-    readonly input: string;
-}
-export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
-    readonly code: "not_multiple_of";
-    readonly divisor: number;
-    readonly input: Input;
-}
-export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
-    readonly code: "unrecognized_keys";
-    readonly keys: string[];
-    readonly input: Record<string, unknown>;
-}
-export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
-    readonly code: "invalid_union";
-    readonly errors: $ZodIssue[][];
-    readonly input: unknown;
-}
-export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
-    readonly code: "invalid_key";
-    readonly origin: "map" | "record";
-    readonly issues: $ZodIssue[];
-    readonly input: Input;
-}
-export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
-    readonly code: "invalid_element";
-    readonly origin: "map" | "set";
-    readonly key: unknown;
-    readonly issues: $ZodIssue[];
-    readonly input: Input;
-}
-export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
-    readonly code: "invalid_value";
-    readonly values: util.Primitive[];
-    readonly input: Input;
-}
-export interface $ZodIssueCustom extends $ZodIssueBase {
-    readonly code: "custom";
-    readonly params?: Record<string, any> | undefined;
-    readonly input: unknown;
-}
-export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
-    format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
-}
-export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
-    format: "regex";
-    pattern: string;
-}
-export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
-    format: "jwt";
-    algorithm?: string;
-}
-export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
-    format: "starts_with";
-    prefix: string;
-}
-export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
-    format: "ends_with";
-    suffix: string;
-}
-export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
-    format: "includes";
-    includes: string;
-}
-export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
-export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
-export type $ZodIssueCode = $ZodIssue["code"];
-export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = util.Flatten<util.MakePartial<T, "message" | "path"> & {
-    /** The input data */
-    readonly input?: unknown;
-    /** The schema or check that originated this issue. */
-    readonly inst?: $ZodType | $ZodCheck;
-    /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
-    readonly continue?: boolean | undefined;
-} & Record<string, any>>;
-export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
-    (issue: $ZodRawIssue<T>): {
-        message: string;
-    } | string | undefined | null;
-}
-export interface $ZodError<T = unknown> extends Error {
-    type: T;
-    issues: $ZodIssue[];
-    _zod: {
-        output: T;
-        def: $ZodIssue[];
-    };
-    stack?: string;
-    name: string;
-}
-export declare const $ZodError: $constructor<$ZodError>;
-interface $ZodRealError<T = any> extends $ZodError<T> {
-}
-export declare const $ZodRealError: $constructor<$ZodRealError>;
-export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
-type _FlattenedError<T, U = string> = {
-    formErrors: U[];
-    fieldErrors: {
-        [P in keyof T]?: U[];
-    };
-};
-export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
-export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
-type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
-    [K in keyof T]?: $ZodFormattedError<T[K], U>;
-} : T extends any[] ? {
-    [k: number]: $ZodFormattedError<T[number], U>;
-} : T extends object ? util.Flatten<{
-    [K in keyof T]?: $ZodFormattedError<T[K], U>;
-}> : any;
-export type $ZodFormattedError<T, U = string> = {
-    _errors: U[];
-} & util.Flatten<_ZodFormattedError<T, U>>;
-export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
-export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
-export type $ZodErrorTree<T, U = string> = T extends [any, ...any[]] ? {
-    errors: U[];
-    items?: {
-        [K in keyof T]?: $ZodErrorTree<T[K], U>;
-    };
-} : T extends any[] ? {
-    errors: U[];
-    items?: Array<$ZodErrorTree<T[number], U>>;
-} : T extends object ? {
-    errors: U[];
-    properties?: {
-        [K in keyof T]?: $ZodErrorTree<T[K], U>;
-    };
-} : {
-    errors: U[];
-};
-export declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
-export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
-/** Format a ZodError as a human-readable string in the following form.
- *
- * From
- *
- * ```ts
- * ZodError {
- *   issues: [
- *     {
- *       expected: 'string',
- *       code: 'invalid_type',
- *       path: [ 'username' ],
- *       message: 'Invalid input: expected string'
- *     },
- *     {
- *       expected: 'number',
- *       code: 'invalid_type',
- *       path: [ 'favoriteNumbers', 1 ],
- *       message: 'Invalid input: expected number'
- *     }
- *   ];
- * }
- * ```
- *
- * to
- *
- * ```
- * username
- *   ✖ Expected number, received string at "username
- * favoriteNumbers[0]
- *   ✖ Invalid input: expected number
- * ```
- */
-export declare function toDotPath(path: (string | number | symbol)[]): string;
-interface BaseError {
-    issues: $ZodIssueBase[];
-}
-export declare function prettifyError(error: BaseError): string;
-export {};

package/node_modules/zod/v4/core/errors.js

@@ -1,195 +0,0 @@
-import { $constructor } from "./core.js";
-import * as util from "./util.js";
-const initializer = (inst, def) => {
-    inst.name = "$ZodError";
-    Object.defineProperty(inst, "_zod", {
-        value: inst._zod,
-        enumerable: false,
-    });
-    Object.defineProperty(inst, "issues", {
-        value: def,
-        enumerable: false,
-    });
-    Object.defineProperty(inst, "message", {
-        get() {
-            return JSON.stringify(def, util.jsonStringifyReplacer, 2);
-        },
-        enumerable: true,
-        // configurable: false,
-    });
-    Object.defineProperty(inst, "toString", {
-        value: () => inst.message,
-        enumerable: false,
-    });
-};
-export const $ZodError = $constructor("$ZodError", initializer);
-export const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
-export function flattenError(error, mapper = (issue) => issue.message) {
-    const fieldErrors = {};
-    const formErrors = [];
-    for (const sub of error.issues) {
-        if (sub.path.length > 0) {
-            fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-            fieldErrors[sub.path[0]].push(mapper(sub));
-        }
-        else {
-            formErrors.push(mapper(sub));
-        }
-    }
-    return { formErrors, fieldErrors };
-}
-export function formatError(error, _mapper) {
-    const mapper = _mapper ||
-        function (issue) {
-            return issue.message;
-        };
-    const fieldErrors = { _errors: [] };
-    const processError = (error) => {
-        for (const issue of error.issues) {
-            if (issue.code === "invalid_union" && issue.errors.length) {
-                issue.errors.map((issues) => processError({ issues }));
-            }
-            else if (issue.code === "invalid_key") {
-                processError({ issues: issue.issues });
-            }
-            else if (issue.code === "invalid_element") {
-                processError({ issues: issue.issues });
-            }
-            else if (issue.path.length === 0) {
-                fieldErrors._errors.push(mapper(issue));
-            }
-            else {
-                let curr = fieldErrors;
-                let i = 0;
-                while (i < issue.path.length) {
-                    const el = issue.path[i];
-                    const terminal = i === issue.path.length - 1;
-                    if (!terminal) {
-                        curr[el] = curr[el] || { _errors: [] };
-                    }
-                    else {
-                        curr[el] = curr[el] || { _errors: [] };
-                        curr[el]._errors.push(mapper(issue));
-                    }
-                    curr = curr[el];
-                    i++;
-                }
-            }
-        }
-    };
-    processError(error);
-    return fieldErrors;
-}
-export function treeifyError(error, _mapper) {
-    const mapper = _mapper ||
-        function (issue) {
-            return issue.message;
-        };
-    const result = { errors: [] };
-    const processError = (error, path = []) => {
-        var _a, _b;
-        for (const issue of error.issues) {
-            if (issue.code === "invalid_union" && issue.errors.length) {
-                // regular union error
-                issue.errors.map((issues) => processError({ issues }, issue.path));
-            }
-            else if (issue.code === "invalid_key") {
-                processError({ issues: issue.issues }, issue.path);
-            }
-            else if (issue.code === "invalid_element") {
-                processError({ issues: issue.issues }, issue.path);
-            }
-            else {
-                const fullpath = [...path, ...issue.path];
-                if (fullpath.length === 0) {
-                    result.errors.push(mapper(issue));
-                    continue;
-                }
-                let curr = result;
-                let i = 0;
-                while (i < fullpath.length) {
-                    const el = fullpath[i];
-                    const terminal = i === fullpath.length - 1;
-                    if (typeof el === "string") {
-                        curr.properties ?? (curr.properties = {});
-                        (_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
-                        curr = curr.properties[el];
-                    }
-                    else {
-                        curr.items ?? (curr.items = []);
-                        (_b = curr.items)[el] ?? (_b[el] = { errors: [] });
-                        curr = curr.items[el];
-                    }
-                    if (terminal) {
-                        curr.errors.push(mapper(issue));
-                    }
-                    i++;
-                }
-            }
-        }
-    };
-    processError(error);
-    return result;
-}
-/** Format a ZodError as a human-readable string in the following form.
- *
- * From
- *
- * ```ts
- * ZodError {
- *   issues: [
- *     {
- *       expected: 'string',
- *       code: 'invalid_type',
- *       path: [ 'username' ],
- *       message: 'Invalid input: expected string'
- *     },
- *     {
- *       expected: 'number',
- *       code: 'invalid_type',
- *       path: [ 'favoriteNumbers', 1 ],
- *       message: 'Invalid input: expected number'
- *     }
- *   ];
- * }
- * ```
- *
- * to
- *
- * ```
- * username
- *   ✖ Expected number, received string at "username
- * favoriteNumbers[0]
- *   ✖ Invalid input: expected number
- * ```
- */
-export function toDotPath(path) {
-    const segs = [];
-    for (const seg of path) {
-        if (typeof seg === "number")
-            segs.push(`[${seg}]`);
-        else if (typeof seg === "symbol")
-            segs.push(`[${JSON.stringify(String(seg))}]`);
-        else if (/[^\w$]/.test(seg))
-            segs.push(`[${JSON.stringify(seg)}]`);
-        else {
-            if (segs.length)
-                segs.push(".");
-            segs.push(seg);
-        }
-    }
-    return segs.join("");
-}
-export function prettifyError(error) {
-    const lines = [];
-    // sort by path length
-    const issues = [...error.issues].sort((a, b) => a.path.length - b.path.length);
-    // Process each issue
-    for (const issue of issues) {
-        lines.push(`✖ ${issue.message}`);
-        if (issue.path?.length)
-            lines.push(`  → at ${toDotPath(issue.path)}`);
-    }
-    // Convert Map to formatted string
-    return lines.join("\n");
-}

package/node_modules/zod/v4/core/function.cjs

@@ -1,102 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$ZodFunction = void 0;
-exports.function = _function;
-const api_js_1 = require("./api.cjs");
-const parse_js_1 = require("./parse.cjs");
-const schemas = __importStar(require("./schemas.cjs"));
-const schemas_js_1 = require("./schemas.cjs");
-class $ZodFunction {
-    constructor(def) {
-        this._def = def;
-        this.def = def;
-    }
-    implement(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = ((...args) => {
-            const parsedArgs = this._def.input ? (0, parse_js_1.parse)(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = func(...parsedArgs);
-            return this._def.output ? (0, parse_js_1.parse)(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    implementAsync(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = (async (...args) => {
-            const parsedArgs = this._def.input ? await (0, parse_js_1.parseAsync)(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = await func(...parsedArgs);
-            return this._def.output ? (0, parse_js_1.parseAsync)(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    input(...args) {
-        const F = this.constructor;
-        if (Array.isArray(args[0])) {
-            return new F({
-                type: "function",
-                input: new schemas_js_1.$ZodTuple({
-                    type: "tuple",
-                    items: args[0],
-                    rest: args[1],
-                }),
-                output: this._def.output,
-            });
-        }
-        return new F({
-            type: "function",
-            input: args[0],
-            output: this._def.output,
-        });
-    }
-    output(output) {
-        const F = this.constructor;
-        return new F({
-            type: "function",
-            input: this._def.input,
-            output,
-        });
-    }
-}
-exports.$ZodFunction = $ZodFunction;
-function _function(params) {
-    return new $ZodFunction({
-        type: "function",
-        input: Array.isArray(params?.input)
-            ? (0, api_js_1._tuple)(schemas.$ZodTuple, params?.input)
-            : (params?.input ?? (0, api_js_1._array)(schemas.$ZodArray, (0, api_js_1._unknown)(schemas.$ZodUnknown))),
-        output: params?.output ?? (0, api_js_1._unknown)(schemas.$ZodUnknown),
-    });
-}

package/node_modules/zod/v4/core/function.d.cts

@@ -1,52 +0,0 @@
-import type * as core from "./core.cjs";
-import * as schemas from "./schemas.cjs";
-import { $ZodTuple } from "./schemas.cjs";
-import type * as util from "./util.cjs";
-export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> {
-    type: "function";
-    input: In;
-    output: Out;
-}
-export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
-export type $ZodFunctionIn = $ZodFunctionArgs;
-export type $ZodFunctionOut = schemas.$ZodType;
-export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
-export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
-export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
-export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => util.MaybeAsync<core.output<Returns>>;
-export declare class $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> {
-    def: $ZodFunctionDef<Args, Returns>;
-    /** @deprecated */
-    _def: $ZodFunctionDef<Args, Returns>;
-    _input: $InferInnerFunctionType<Args, Returns>;
-    _output: $InferOuterFunctionType<Args, Returns>;
-    constructor(def: $ZodFunctionDef<Args, Returns>);
-    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
-    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
-    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
-    input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
-    output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
-}
-export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.$ZodType> {
-    input?: I;
-    output?: O;
-}
-declare function _function(): $ZodFunction;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
-    input: In;
-}): $ZodFunction<$ZodTuple<In, null>, $ZodFunctionOut>;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>, const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    input: In;
-    output: Out;
-}): $ZodFunction<$ZodTuple<In, null>, Out>;
-declare function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
-    input: In;
-}): $ZodFunction<In, $ZodFunctionOut>;
-declare function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    output: Out;
-}): $ZodFunction<$ZodFunctionIn, Out>;
-declare function _function<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends schemas.$ZodType = schemas.$ZodType>(params?: {
-    input: In;
-    output: Out;
-}): $ZodFunction<In, Out>;
-export { _function as function };

package/node_modules/zod/v4/core/function.d.ts

@@ -1,52 +0,0 @@
-import type * as core from "./core.js";
-import * as schemas from "./schemas.js";
-import { $ZodTuple } from "./schemas.js";
-import type * as util from "./util.js";
-export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> {
-    type: "function";
-    input: In;
-    output: Out;
-}
-export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
-export type $ZodFunctionIn = $ZodFunctionArgs;
-export type $ZodFunctionOut = schemas.$ZodType;
-export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
-export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
-export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
-export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => util.MaybeAsync<core.output<Returns>>;
-export declare class $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> {
-    def: $ZodFunctionDef<Args, Returns>;
-    /** @deprecated */
-    _def: $ZodFunctionDef<Args, Returns>;
-    _input: $InferInnerFunctionType<Args, Returns>;
-    _output: $InferOuterFunctionType<Args, Returns>;
-    constructor(def: $ZodFunctionDef<Args, Returns>);
-    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
-    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
-    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
-    input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
-    output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
-}
-export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.$ZodType> {
-    input?: I;
-    output?: O;
-}
-declare function _function(): $ZodFunction;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
-    input: In;
-}): $ZodFunction<$ZodTuple<In, null>, $ZodFunctionOut>;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>, const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    input: In;
-    output: Out;
-}): $ZodFunction<$ZodTuple<In, null>, Out>;
-declare function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
-    input: In;
-}): $ZodFunction<In, $ZodFunctionOut>;
-declare function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    output: Out;
-}): $ZodFunction<$ZodFunctionIn, Out>;
-declare function _function<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends schemas.$ZodType = schemas.$ZodType>(params?: {
-    input: In;
-    output: Out;
-}): $ZodFunction<In, Out>;
-export { _function as function };

package/node_modules/zod/v4/core/function.js

@@ -1,75 +0,0 @@
-import { _array, _tuple, _unknown } from "./api.js";
-import { parse, parseAsync } from "./parse.js";
-import * as schemas from "./schemas.js";
-import { $ZodTuple } from "./schemas.js";
-export class $ZodFunction {
-    constructor(def) {
-        this._def = def;
-        this.def = def;
-    }
-    implement(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = ((...args) => {
-            const parsedArgs = this._def.input ? parse(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = func(...parsedArgs);
-            return this._def.output ? parse(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    implementAsync(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = (async (...args) => {
-            const parsedArgs = this._def.input ? await parseAsync(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = await func(...parsedArgs);
-            return this._def.output ? parseAsync(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    input(...args) {
-        const F = this.constructor;
-        if (Array.isArray(args[0])) {
-            return new F({
-                type: "function",
-                input: new $ZodTuple({
-                    type: "tuple",
-                    items: args[0],
-                    rest: args[1],
-                }),
-                output: this._def.output,
-            });
-        }
-        return new F({
-            type: "function",
-            input: args[0],
-            output: this._def.output,
-        });
-    }
-    output(output) {
-        const F = this.constructor;
-        return new F({
-            type: "function",
-            input: this._def.input,
-            output,
-        });
-    }
-}
-function _function(params) {
-    return new $ZodFunction({
-        type: "function",
-        input: Array.isArray(params?.input)
-            ? _tuple(schemas.$ZodTuple, params?.input)
-            : (params?.input ?? _array(schemas.$ZodArray, _unknown(schemas.$ZodUnknown))),
-        output: params?.output ?? _unknown(schemas.$ZodUnknown),
-    });
-}
-export { _function as function };