@openclaw/firecrawl-plugin 2026.9.8 → 2026.10.1-beta.1

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

@@ -1,311 +0,0 @@
-import * as util from "./util.js";
-export class $ZodCyclicError extends Error {
-    constructor() {
-        super(`Cannot parse a reference cycle that closes through a transform`);
-        this.name = "ZodCyclicError";
-    }
-}
-/** Keyed off the context object every schema in one parse call already shares. */
-const STATE = "~memo";
-const NO_ISSUES = [];
-// a value a cycle can close through
-function isRef(value) {
-    return value !== null && typeof value === "object";
-}
-// Receivers prefix paths in place, so the cache and every hand-out need their own copies.
-function cloneIssues(issues) {
-    return issues.map((iss) => (iss.path ? { ...iss, path: iss.path.slice() } : { ...iss }));
-}
-const recursive = /*@__PURE__*/ new WeakMap();
-/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */
-const NONE = 0;
-const ASSUMED = 1;
-const PROVEN = 2;
-/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */
-function isRecursive(inst, stack, resolve) {
-    const cached = recursive.get(inst);
-    if (cached !== undefined)
-        return cached ? PROVEN : NONE;
-    // Relative to the walk in progress, so not cached.
-    if (stack.has(inst))
-        return PROVEN;
-    stack.add(inst);
-    let result = NONE;
-    const check = (child) => {
-        if (result !== PROVEN && child?._zod) {
-            const answer = isRecursive(child, stack, resolve);
-            if (answer > result)
-                result = answer;
-        }
-    };
-    // `Reflect.ownKeys` rather than `Object.keys`, so a cycle through a declared symbol key is still seen
-    const shape = (sh, spread) => {
-        let answer = NONE;
-        for (const key of Reflect.ownKeys(sh)) {
-            const desc = Object.getOwnPropertyDescriptor(sh, key);
-            // an object resolves its shape by spread, so a key it does not enumerate is never parsed; `z.properties` reads every own key and so keeps them all
-            if (spread && !desc.enumerable)
-                continue;
-            // resolving runs user code, and a factory mints a fresh subtree per read, so an edge the walk can't follow counts as a cycle
-            const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
-            if (child > answer)
-                answer = child;
-        }
-        return answer;
-    };
-    const merge = (answer) => {
-        if (answer > result)
-            result = answer;
-    };
-    const def = inst._zod.def;
-    const kind = def.type;
-    switch (kind) {
-        case "object": {
-            const raw = util.rawShape(def);
-            // a def with no raw shape answers `shape` from an accessor of its own, and running that can mint a whole fresh subtree
-            merge(raw ? shape(raw, true) : ASSUMED);
-            check(def.catchall);
-            break;
-        }
-        case "array":
-            check(def.element);
-            break;
-        case "tuple":
-            for (const el of def.items)
-                check(el);
-            check(def.rest);
-            break;
-        case "record":
-        case "map":
-            check(def.keyType);
-            check(def.valueType);
-            break;
-        case "set":
-            check(def.valueType);
-            break;
-        case "union":
-            for (const el of def.options)
-                check(el);
-            break;
-        case "intersection":
-            check(def.left);
-            check(def.right);
-            break;
-        case "optional":
-        case "nullable":
-        case "default":
-        case "prefault":
-        case "catch":
-        case "readonly":
-        case "nonoptional":
-        case "promise":
-        case "success":
-            check(def.innerType);
-            break;
-        case "pipe":
-            check(def.in);
-            check(def.out);
-            break;
-        case "function":
-            check(def.input);
-            check(def.output);
-            break;
-        // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
-        case "lazy": {
-            const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : undefined);
-            // walked with resolution off: one hop sees past the deferral, and a lazy that yields only another unresolved lazy is generative, so it stops there
-            merge(inner ? isRecursive(inner, stack, false) : ASSUMED);
-            break;
-        }
-        // a leaf by choice: `parts` are regex fragments, not data positions
-        case "template_literal":
-        // leaves
-        case "string":
-        case "number":
-        case "int":
-        case "boolean":
-        case "bigint":
-        case "symbol":
-        case "undefined":
-        case "null":
-        case "void":
-        case "never":
-        case "any":
-        case "unknown":
-        case "date":
-        case "nan":
-        case "enum":
-        case "literal":
-        case "file":
-        case "transform":
-        case "custom":
-            break;
-        default: {
-            // a new built-in kind becomes a compile error here
-            kind;
-            // a user-defined kind can still hold children, and only its author knows where, so fall back to scanning the def — skipping accessors, since reading one can run user code
-            for (const key in def) {
-                const desc = Object.getOwnPropertyDescriptor(def, key);
-                if (!desc || desc.get)
-                    continue;
-                const value = desc.value;
-                if (!value || typeof value !== "object")
-                    continue;
-                if (value._zod)
-                    check(value);
-                else if (Array.isArray(value))
-                    for (const el of value)
-                        check(el);
-            }
-        }
-    }
-    stack.delete(inst);
-    return settle(inst, result);
-}
-/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */
-function settle(inst, answer) {
-    if (answer !== ASSUMED)
-        recursive.set(inst, answer === PROVEN);
-    return answer;
-}
-/**
- * Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.
- * Exported for `z.compile`, which refuses to compile such a schema: cycle
- * breaking is driven from here off state keyed on the parse context, and a
- * generated fast path has no context to key on.
- */
-export function isRecursiveSchema(inst) {
-    // z.compile never parses, so nothing would ever resolve a lazy for it; it runs once and already treats a throw here as recursive
-    return isRecursive(inst, new Set(), true) !== NONE;
-}
-function bucketFor(state, inst) {
-    let bucket = state.buckets.get(inst);
-    if (!bucket) {
-        bucket = new WeakMap();
-        state.buckets.set(inst, bucket);
-    }
-    return bucket;
-}
-// Set immediately before delegating to core and cleared immediately after, so `alloc` registers only for a visit this module is driving.
-let handoff;
-// Allocated but unfinished entries. `alloc` and the matching pop both happen in the synchronous part of a parse, so they nest even when children are async, and one stack serves every schema.
-const open = [];
-const memo = {
-    alloc(_inst, payload, empty) {
-        const bucket = handoff;
-        if (!bucket)
-            return empty;
-        handoff = undefined;
-        const entry = { value: empty, issues: null };
-        bucket.set(payload.value, entry);
-        open.push(entry);
-        return empty;
-    },
-    guard(inst) {
-        var _a;
-        (_a = inst._zod).deferred ?? (_a.deferred = []);
-        inst._zod.deferred.push(() => {
-            const base = inst._zod.parse;
-            const wrapped = (payload, ctx) => {
-                // The value is a placeholder a back-edge is still waiting on, so the cycle closes through this transform. Its output can't exist in time to bind.
-                if (ctx.direction !== "backward" && isBackEdge(ctx, payload.value))
-                    throw new $ZodCyclicError();
-                return base(payload, ctx);
-            };
-            inst._zod.parse = wrapped;
-            if (inst._zod.run === base)
-                inst._zod.run = wrapped;
-        });
-    },
-    attach(inst) {
-        var _a;
-        let isRecursiveInst;
-        let rechecked = false;
-        // a recursive schema is re-entered many times per parse and its bucket never changes
-        let lastCtx;
-        let lastBucket;
-        // Wraps `parse` in a deferred so it sees the container's final parse. Core's own deferred copies `parse` into `run` when there are no checks, and it ran first, so `run` is patched to match; with checks, `run` reads `parse` dynamically.
-        (_a = inst._zod).deferred ?? (_a.deferred = []);
-        inst._zod.deferred.push(() => {
-            const base = inst._zod.parse;
-            const wrapped = (payload, ctx) => {
-                if (isRecursiveInst === undefined) {
-                    const walked = isRecursive(inst, new Set(), false);
-                    if (walked === NONE) {
-                        // Nothing here can ever fire, so take it back out.
-                        inst._zod.parse = base;
-                        if (inst._zod.run === wrapped)
-                            inst._zod.run = base;
-                        return base(payload, ctx);
-                    }
-                    // this parse resolves the deferred edges on its own path, so ask once more before latching
-                    if (walked === PROVEN || rechecked)
-                        isRecursiveInst = true;
-                    else
-                        rechecked = true;
-                }
-                const input = payload.value;
-                if (!isRef(input))
-                    return base(payload, ctx);
-                let state = ctx[STATE];
-                if (!state) {
-                    state = { buckets: new WeakMap(), backEdges: undefined };
-                    ctx[STATE] = state;
-                }
-                let bucket;
-                if (lastCtx === ctx) {
-                    bucket = lastBucket;
-                }
-                else {
-                    bucket = bucketFor(state, inst);
-                    lastCtx = ctx;
-                    lastBucket = bucket;
-                }
-                const hit = bucket.get(input);
-                if (hit) {
-                    payload.value = hit.value;
-                    if (hit.issues) {
-                        if (hit.issues.length)
-                            payload.issues.push(...cloneIssues(hit.issues));
-                    }
-                    else {
-                        // Still being parsed: its own checks cover it, so skip them here.
-                        payload.memo = true;
-                        state.backEdges ?? (state.backEdges = new WeakSet());
-                        state.backEdges.add(hit.value);
-                    }
-                    return payload;
-                }
-                handoff = bucket;
-                const depth = open.length;
-                const result = base(payload, ctx);
-                handoff = undefined;
-                // A container that rejected its input outright allocated nothing.
-                const entry = open.length > depth ? open.pop() : undefined;
-                // Both paths written out so the sync one allocates no closure. It runs once per node, and capturing here cost more than everything else combined.
-                if (result instanceof Promise) {
-                    return result.then((r) => {
-                        if (entry)
-                            entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;
-                        return r;
-                    });
-                }
-                if (entry)
-                    entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;
-                return result;
-            };
-            inst._zod.parse = wrapped;
-            if (inst._zod.run === base)
-                inst._zod.run = wrapped;
-        });
-    },
-};
-/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
-export function memoizer() {
-    return memo;
-}
-/** Whether this value is a node a back-edge resolved to before it finished. */
-export function isBackEdge(ctx, value) {
-    const backEdges = ctx[STATE]?.backEdges;
-    return backEdges !== undefined && isRef(value) && backEdges.has(value);
-}

package/node_modules/zod/v4/core/package.json

@@ -1,7 +0,0 @@
-{ 
-  "type": "module",
-  "main": "./index.cjs",
-  "module": "./index.js",
-  "types": "./index.d.cts",
-  "sideEffects": false
-}

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

@@ -1,233 +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.safeDecodeAsync = exports._safeDecodeAsync = exports.safeEncodeAsync = exports._safeEncodeAsync = exports.safeDecode = exports._safeDecode = exports.safeEncode = exports._safeEncode = exports.decodeAsync = exports._decodeAsync = exports.encodeAsync = exports._encodeAsync = exports.decode = exports._decode = exports.encode = exports._encode = exports.validateAsync = exports.validate = exports.safeParseAsync = exports._safeParseAsync = exports.safeParse = exports._safeParse = exports.parseAsync = exports._parseAsync = exports.parse = exports._parse = void 0;
-const core = __importStar(require("./core.cjs"));
-const errors = __importStar(require("./errors.cjs"));
-const util = __importStar(require("./util.cjs"));
-// Always both keys, so the `_params` read site in `_parse` sees one object shape rather than two.
-function finalizeParams(callee, params) {
-    return { callee: params?.callee ?? callee, Err: params?.Err };
-}
-const _parse = (_Err) => {
-    const fn = (schema, value, _ctx, _params) => {
-        const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-        const result = schema._zod.run({ value, issues: [] }, ctx);
-        if (result instanceof Promise) {
-            throw new core.$ZodAsyncError();
-        }
-        if (result.issues.length) {
-            const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
-            util.captureStackTrace(e, _params?.callee ?? fn);
-            throw e;
-        }
-        return result.value;
-    };
-    return fn;
-};
-exports._parse = _parse;
-exports.parse = (0, exports._parse)(errors.$ZodRealError);
-const _parseAsync = (_Err) => {
-    const fn = async (schema, value, _ctx, params) => {
-        const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-        let result = schema._zod.run({ value, issues: [] }, ctx);
-        if (result instanceof Promise)
-            result = await result;
-        if (result.issues.length) {
-            const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
-            util.captureStackTrace(e, params?.callee ?? fn);
-            throw e;
-        }
-        return result.value;
-    };
-    return fn;
-};
-exports._parseAsync = _parseAsync;
-exports.parseAsync = (0, exports._parseAsync)(errors.$ZodRealError);
-const _safeParse = (_Err) => (schema, value, _ctx) => {
-    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-    const result = schema._zod.run({ value, issues: [] }, ctx);
-    if (result instanceof Promise) {
-        throw new core.$ZodAsyncError();
-    }
-    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
-};
-exports._safeParse = _safeParse;
-exports.safeParse = (0, exports._safeParse)(errors.$ZodRealError);
-// the error is built on the first read of `error`: finalizing the issues and constructing the instance is most of a failing parse, and a caller that only branches on `success` never pays it. a getter in the literal keeps this small; the alternative, one shared accessor descriptor plus a hidden state slot, reads ~15% faster but costs ~75 B gzipped in every bundle
-function failure(Err, issues, ctx) {
-    let error;
-    return {
-        success: false,
-        get error() {
-            if (!error) {
-                error = new Err(issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
-                // finalizeIssue drops `input`, so the built error holds nothing; keeping the raw issues past this point pins the parsed value for the life of the result
-                issues = undefined;
-                ctx = undefined;
-            }
-            return error;
-        },
-        set error(e) {
-            error = e;
-            // a replacement makes the getter's branch unreachable, so the captures have to go here too
-            issues = undefined;
-            ctx = undefined;
-        },
-    };
-}
-const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-    let result = schema._zod.run({ value, issues: [] }, ctx);
-    if (result instanceof Promise)
-        result = await result;
-    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
-};
-exports._safeParseAsync = _safeParseAsync;
-exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodRealError);
-// registry mirrors of the compiler's sentinels, so this module never imports the compiler
-const COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
-const COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
-// Deliberately tiny, because v8 will not inline a body carrying the fallback's object literals and throw. Everything that is not the compiled happy path lives in validateFallback, and that split is worth ~35% on a compiled schema.
-exports.validate = ((schema, value, _ctx) => {
-    const validator = schema._zod.bag.validator;
-    if (validator !== undefined) {
-        if (validator(value) !== COMPILE_INVALID)
-            return true;
-        // a definite sentinel means the runtime would reject, so skip the re-parse; a ctx can still change the answer
-        if (validator.definite === true && _ctx === undefined)
-            return false;
-    }
-    return validateFallback(schema, value, _ctx);
-});
-function validateFallback(schema, value, _ctx) {
-    const ctx = _ctx
-        ? { ..._ctx, async: false, abortEarly: true }
-        : { async: false, abortEarly: true };
-    const fallbackRun = schema._zod.bag.fallbackRun;
-    let result;
-    if (fallbackRun) {
-        // skip nested fast paths on the fallback, so user callbacks keep the at-most-twice bound
-        ctx[COMPILE_FALLBACK] = true;
-        result = fallbackRun({ value, issues: [] }, ctx);
-    }
-    else {
-        result = schema._zod.run({ value, issues: [] }, ctx);
-    }
-    if (result instanceof Promise) {
-        throw new core.$ZodAsyncError();
-    }
-    return result.issues.length === 0;
-}
-// no fast path: the compiler keeps async parses on the runtime, because a promise-returning callback that is not declared async compiles to a throw
-const validateAsync = async (schema, value, _ctx) => {
-    const ctx = _ctx
-        ? { ..._ctx, async: true, abortEarly: true }
-        : { async: true, abortEarly: true };
-    let result = schema._zod.run({ value, issues: [] }, ctx);
-    if (result instanceof Promise)
-        result = await result;
-    return result.issues.length === 0;
-};
-exports.validateAsync = validateAsync;
-const _encode = (_Err) => {
-    const parse = (0, exports._parse)(_Err);
-    const fn = (schema, value, _ctx, _params) => {
-        const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-        return parse(schema, value, ctx, finalizeParams(fn, _params));
-    };
-    return fn;
-};
-exports._encode = _encode;
-exports.encode = (0, exports._encode)(errors.$ZodRealError);
-const _decode = (_Err) => {
-    const parse = (0, exports._parse)(_Err);
-    const fn = (schema, value, _ctx, _params) => {
-        return parse(schema, value, _ctx, finalizeParams(fn, _params));
-    };
-    return fn;
-};
-exports._decode = _decode;
-exports.decode = (0, exports._decode)(errors.$ZodRealError);
-const _encodeAsync = (_Err) => {
-    const parseAsync = (0, exports._parseAsync)(_Err);
-    const fn = async (schema, value, _ctx, _params) => {
-        const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-        return (await parseAsync(schema, value, ctx, finalizeParams(fn, _params)));
-    };
-    return fn;
-};
-exports._encodeAsync = _encodeAsync;
-exports.encodeAsync = (0, exports._encodeAsync)(errors.$ZodRealError);
-const _decodeAsync = (_Err) => {
-    const parseAsync = (0, exports._parseAsync)(_Err);
-    const fn = async (schema, value, _ctx, _params) => {
-        return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));
-    };
-    return fn;
-};
-exports._decodeAsync = _decodeAsync;
-exports.decodeAsync = (0, exports._decodeAsync)(errors.$ZodRealError);
-const _safeEncode = (_Err) => (schema, value, _ctx) => {
-    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return (0, exports._safeParse)(_Err)(schema, value, ctx);
-};
-exports._safeEncode = _safeEncode;
-exports.safeEncode = (0, exports._safeEncode)(errors.$ZodRealError);
-const _safeDecode = (_Err) => (schema, value, _ctx) => {
-    return (0, exports._safeParse)(_Err)(schema, value, _ctx);
-};
-exports._safeDecode = _safeDecode;
-exports.safeDecode = (0, exports._safeDecode)(errors.$ZodRealError);
-const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return (0, exports._safeParseAsync)(_Err)(schema, value, ctx);
-};
-exports._safeEncodeAsync = _safeEncodeAsync;
-exports.safeEncodeAsync = (0, exports._safeEncodeAsync)(errors.$ZodRealError);
-const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
-    return (0, exports._safeParseAsync)(_Err)(schema, value, _ctx);
-};
-exports._safeDecodeAsync = _safeDecodeAsync;
-exports.safeDecodeAsync = (0, exports._safeDecodeAsync)(errors.$ZodRealError);
-
-// seal-cjs-exports
-(function () {
-  var keys = Object.getOwnPropertyNames(exports);
-  for (var i = 0; i < keys.length; i++) {
-    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
-    if (!desc || !desc.get || !desc.configurable) continue;
-    var value;
-    try {
-      value = desc.get();
-    } catch (e) {
-      continue;
-    }
-    // a circular require may not have settled this one yet, so leave it live
-    if (value === undefined) continue;
-    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
-  }
-  Object.freeze(exports);
-})();

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

@@ -1,52 +0,0 @@
-import * as core from "./core.cjs";
-import * as errors from "./errors.cjs";
-import type * as schemas from "./schemas.cjs";
-import * as util from "./util.cjs";
-export type $ZodErrorClass = {
-    new (issues: errors.$ZodIssue[]): errors.$ZodError;
-};
-type $ParseParams = {
-    callee?: util.AnyFunc;
-    Err?: $ZodErrorClass | undefined;
-};
-export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
-export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
-export declare const parse: $Parse;
-export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
-export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
-export declare const parseAsync: $ParseAsync;
-export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
-export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
-export declare const safeParse: $SafeParse;
-export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
-export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
-export declare const safeParseAsync: $SafeParseAsync;
-export type $Validate = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => value is core.input<T>;
-export declare const validate: $Validate;
-export type $ValidateAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<boolean>;
-export declare const validateAsync: $ValidateAsync;
-export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.input<T>;
-export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
-export declare const encode: $Encode;
-export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
-export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
-export declare const decode: $Decode;
-export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.input<T>>;
-export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
-export declare const encodeAsync: $EncodeAsync;
-export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
-export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
-export declare const decodeAsync: $DecodeAsync;
-export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
-export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
-export declare const safeEncode: $SafeEncode;
-export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
-export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
-export declare const safeDecode: $SafeDecode;
-export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
-export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
-export declare const safeEncodeAsync: $SafeEncodeAsync;
-export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
-export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
-export declare const safeDecodeAsync: $SafeDecodeAsync;
-export {};

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

@@ -1,52 +0,0 @@
-import * as core from "./core.js";
-import * as errors from "./errors.js";
-import type * as schemas from "./schemas.js";
-import * as util from "./util.js";
-export type $ZodErrorClass = {
-    new (issues: errors.$ZodIssue[]): errors.$ZodError;
-};
-type $ParseParams = {
-    callee?: util.AnyFunc;
-    Err?: $ZodErrorClass | undefined;
-};
-export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
-export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
-export declare const parse: $Parse;
-export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
-export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
-export declare const parseAsync: $ParseAsync;
-export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
-export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
-export declare const safeParse: $SafeParse;
-export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
-export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
-export declare const safeParseAsync: $SafeParseAsync;
-export type $Validate = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => value is core.input<T>;
-export declare const validate: $Validate;
-export type $ValidateAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<boolean>;
-export declare const validateAsync: $ValidateAsync;
-export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.input<T>;
-export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
-export declare const encode: $Encode;
-export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
-export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
-export declare const decode: $Decode;
-export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.input<T>>;
-export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
-export declare const encodeAsync: $EncodeAsync;
-export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
-export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
-export declare const decodeAsync: $DecodeAsync;
-export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
-export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
-export declare const safeEncode: $SafeEncode;
-export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
-export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
-export declare const safeDecode: $SafeDecode;
-export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
-export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
-export declare const safeEncodeAsync: $SafeEncodeAsync;
-export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
-export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
-export declare const safeDecodeAsync: $SafeDecodeAsync;
-export {};