@wopee-io/wopee.wdio 5.2.5 → 6.0.1

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

@@ -1,36 +1,82 @@
 import { $constructor } from "./core.js";
 import * as util from "./util.js";
+/* Computing the message eagerly is expensive (pretty-printed JSON of all
+ * issues), so defer it until first read. The accessor functions and
+ * descriptors are shared across instances to keep error construction
+ * cheap; the computed message is cached on the internals object. The
+ * setter preserves plain assignment semantics for consumers that
+ * overwrite `message`. */
+function _getMessage() {
+    const internals = this._zod;
+    internals.message ?? (internals.message = JSON.stringify(internals.def, util.jsonStringifyReplacer, 2));
+    return internals.message;
+}
+function _setMessage(value) {
+    this._zod.message = value;
+}
+const _messageDesc = {
+    get: _getMessage,
+    set: _setMessage,
+    enumerable: true,
+    configurable: true,
+};
+const _issuesDesc = { value: undefined, enumerable: false };
+/* Prototypes that already carry the lazy `toString`. Seeded with the
+ * intrinsics so that `init` on a foreign object — it accepts any object —
+ * can never install an accessor onto a prototype we do not own. */
+const _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
 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,
-    });
+    // `_zod` is already non-enumerable: $constructor's init defined it with this same descriptor
+    _issuesDesc.value = def;
+    Object.defineProperty(inst, "issues", _issuesDesc);
+    // Clear the shared slot; a retained `value` pins the last error's issues.
+    _issuesDesc.value = undefined;
+    Object.defineProperty(inst, "message", _messageDesc);
+    /* `toString` lives as a non-enumerable lazy getter on the shared
+     * prototype; on first access it caches a per-instance closure so
+     * detached usage still works. */
+    const proto = Object.getPrototypeOf(inst);
+    if (!_installedToString.has(proto)) {
+        _installedToString.add(proto);
+        Object.defineProperty(proto, "toString", {
+            configurable: true,
+            enumerable: false,
+            get() {
+                const value = () => this.message;
+                Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
+                return value;
+            },
+            set(value) {
+                Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
+            },
+        });
+    }
 };
 export const $ZodError = $constructor("$ZodError", initializer);
-export const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+export const $ZodRealError = $constructor("$ZodError", initializer, undefined, {
+    Parent: Error,
+});
+/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
+ * ("toString", "constructor") would otherwise read through to the prototype, and assigning
+ * "__proto__" would hit the setter instead of creating a key. */
+function node(obj, key, make) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+        if (key === "__proto__") {
+            Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
+        }
+        else {
+            obj[key] = make();
+        }
+    }
+    return obj[key];
+}
 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));
+            node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
         }
         else {
             formErrors.push(mapper(sub));
@@ -38,41 +84,58 @@ export function flattenError(error, mapper = (issue) => issue.message) {
     }
     return { formErrors, fieldErrors };
 }
-export function formatError(error, _mapper) {
-    const mapper = _mapper ||
-        function (issue) {
-            return issue.message;
-        };
+export function formatError(error, mapper = (issue) => issue.message) {
     const fieldErrors = { _errors: [] };
-    const processError = (error) => {
+    const processError = (error, path = []) => {
         for (const issue of error.issues) {
             if (issue.code === "invalid_union" && issue.errors.length) {
-                issue.errors.map((issues) => processError({ issues }));
+                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
             }
             else if (issue.code === "invalid_key") {
-                processError({ issues: issue.issues });
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
             }
             else if (issue.code === "invalid_element") {
-                processError({ issues: issue.issues });
-            }
-            else if (issue.path.length === 0) {
-                fieldErrors._errors.push(mapper(issue));
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
             }
             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));
+                const fullpath = [...path, ...issue.path];
+                if (fullpath.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < fullpath.length) {
+                        const el = fullpath[i];
+                        const terminal = i === fullpath.length - 1;
+                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
+                        if (el === "_errors") {
+                            if (terminal)
+                                curr._errors.push(mapper(issue));
+                            i++;
+                            continue;
+                        }
+                        // A path element may collide with an inherited property name such as
+                        // "__proto__" or "constructor". Truthiness checks read the prototype
+                        // (so no node is created, then ._errors.push throws), and bracket
+                        // assignment of "__proto__" hits the setter instead of creating an
+                        // own key. Guard the read with hasOwnProperty and create the node
+                        // with defineProperty so any path element becomes a real own key.
+                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+                            Object.defineProperty(curr, el, {
+                                value: { _errors: [] },
+                                enumerable: true,
+                                writable: true,
+                                configurable: true,
+                            });
+                        }
+                        const node = curr[el];
+                        if (terminal) {
+                            node._errors.push(mapper(issue));
+                        }
+                        curr = node;
+                        i++;
                     }
-                    curr = curr[el];
-                    i++;
                 }
             }
         }
@@ -80,24 +143,20 @@ export function formatError(error, _mapper) {
     processError(error);
     return fieldErrors;
 }
-export function treeifyError(error, _mapper) {
-    const mapper = _mapper ||
-        function (issue) {
-            return issue.message;
-        };
+export function treeifyError(error, mapper = (issue) => issue.message) {
     const result = { errors: [] };
     const processError = (error, path = []) => {
-        var _a, _b;
+        var _a;
         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));
+                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
             }
             else if (issue.code === "invalid_key") {
-                processError({ issues: issue.issues }, issue.path);
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
             }
             else if (issue.code === "invalid_element") {
-                processError({ issues: issue.issues }, issue.path);
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
             }
             else {
                 const fullpath = [...path, ...issue.path];
@@ -112,12 +171,24 @@ export function treeifyError(error, _mapper) {
                     const terminal = i === fullpath.length - 1;
                     if (typeof el === "string") {
                         curr.properties ?? (curr.properties = {});
-                        (_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
+                        // el may collide with an inherited property name ("__proto__",
+                        // "constructor", ...); ??= reads the prototype so the node is never
+                        // created and curr.errors.push throws. Guard with hasOwnProperty and
+                        // create the node with defineProperty so "__proto__" becomes a real
+                        // own key rather than invoking the prototype setter.
+                        if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {
+                            Object.defineProperty(curr.properties, el, {
+                                value: { errors: [] },
+                                enumerable: true,
+                                writable: true,
+                                configurable: true,
+                            });
+                        }
                         curr = curr.properties[el];
                     }
                     else {
                         curr.items ?? (curr.items = []);
-                        (_b = curr.items)[el] ?? (_b[el] = { errors: [] });
+                        (_a = curr.items)[el] ?? (_a[el] = { errors: [] });
                         curr = curr.items[el];
                     }
                     if (terminal) {
@@ -163,8 +234,9 @@ export function treeifyError(error, _mapper) {
  *   ✖ Invalid input: expected number
  * ```
  */
-export function toDotPath(path) {
+export function toDotPath(_path) {
     const segs = [];
+    const path = _path.map((seg) => (typeof seg === "object" ? seg.key : seg));
     for (const seg of path) {
         if (typeof seg === "number")
             segs.push(`[${seg}]`);
@@ -183,7 +255,7 @@ export function toDotPath(path) {
 export function prettifyError(error) {
     const lines = [];
     // sort by path length
-    const issues = [...error.issues].sort((a, b) => a.path.length - b.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}`);

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

@@ -26,19 +26,45 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONSchema = exports.locales = exports.regexes = exports.util = void 0;
+exports.JSONSchema = exports.JSONSchemaGenerator = exports.toJSONSchema = exports.locales = exports.regexes = exports.toZod = exports.util = void 0;
 __exportStar(require("./core.cjs"), exports);
 __exportStar(require("./parse.cjs"), exports);
 __exportStar(require("./errors.cjs"), exports);
 __exportStar(require("./schemas.cjs"), exports);
+__exportStar(require("./memoizer.cjs"), exports);
 __exportStar(require("./checks.cjs"), exports);
 __exportStar(require("./versions.cjs"), exports);
 exports.util = __importStar(require("./util.cjs"));
+var util_js_1 = require("./util.cjs");
+Object.defineProperty(exports, "toZod", { enumerable: true, get: function () { return util_js_1.toZod; } });
 exports.regexes = __importStar(require("./regexes.cjs"));
 exports.locales = __importStar(require("../locales/index.cjs"));
 __exportStar(require("./registries.cjs"), exports);
 __exportStar(require("./doc.cjs"), exports);
-__exportStar(require("./function.cjs"), exports);
+__exportStar(require("./compile.cjs"), exports);
 __exportStar(require("./api.cjs"), exports);
 __exportStar(require("./to-json-schema.cjs"), exports);
+var json_schema_processors_js_1 = require("./json-schema-processors.cjs");
+Object.defineProperty(exports, "toJSONSchema", { enumerable: true, get: function () { return json_schema_processors_js_1.toJSONSchema; } });
+var json_schema_generator_js_1 = require("./json-schema-generator.cjs");
+Object.defineProperty(exports, "JSONSchemaGenerator", { enumerable: true, get: function () { return json_schema_generator_js_1.JSONSchemaGenerator; } });
 exports.JSONSchema = __importStar(require("./json-schema.cjs"));
+
+// 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/index.d.cts

@@ -2,14 +2,18 @@ export * from "./core.cjs";
 export * from "./parse.cjs";
 export * from "./errors.cjs";
 export * from "./schemas.cjs";
+export * from "./memoizer.cjs";
 export * from "./checks.cjs";
 export * from "./versions.cjs";
 export * as util from "./util.cjs";
+export { toZod } from "./util.cjs";
 export * as regexes from "./regexes.cjs";
 export * as locales from "../locales/index.cjs";
 export * from "./registries.cjs";
 export * from "./doc.cjs";
-export * from "./function.cjs";
+export * from "./compile.cjs";
 export * from "./api.cjs";
 export * from "./to-json-schema.cjs";
+export { toJSONSchema } from "./json-schema-processors.cjs";
+export { JSONSchemaGenerator } from "./json-schema-generator.cjs";
 export * as JSONSchema from "./json-schema.cjs";

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

@@ -2,14 +2,18 @@ export * from "./core.js";
 export * from "./parse.js";
 export * from "./errors.js";
 export * from "./schemas.js";
+export * from "./memoizer.js";
 export * from "./checks.js";
 export * from "./versions.js";
 export * as util from "./util.js";
+export { toZod } from "./util.js";
 export * as regexes from "./regexes.js";
 export * as locales from "../locales/index.js";
 export * from "./registries.js";
 export * from "./doc.js";
-export * from "./function.js";
+export * from "./compile.js";
 export * from "./api.js";
 export * from "./to-json-schema.js";
+export { toJSONSchema } from "./json-schema-processors.js";
+export { JSONSchemaGenerator } from "./json-schema-generator.js";
 export * as JSONSchema from "./json-schema.js";

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

@@ -2,14 +2,18 @@ export * from "./core.js";
 export * from "./parse.js";
 export * from "./errors.js";
 export * from "./schemas.js";
+export * from "./memoizer.js";
 export * from "./checks.js";
 export * from "./versions.js";
 export * as util from "./util.js";
+export { toZod } from "./util.js";
 export * as regexes from "./regexes.js";
 export * as locales from "../locales/index.js";
 export * from "./registries.js";
 export * from "./doc.js";
-export * from "./function.js";
+export * from "./compile.js";
 export * from "./api.js";
 export * from "./to-json-schema.js";
+export { toJSONSchema } from "./json-schema-processors.js";
+export { JSONSchemaGenerator } from "./json-schema-generator.js";
 export * as JSONSchema from "./json-schema.js";

package/node_modules/zod/v4/core/json-schema-generator.cjs

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONSchemaGenerator = void 0;
+const json_schema_processors_js_1 = require("./json-schema-processors.cjs");
+const to_json_schema_js_1 = require("./to-json-schema.cjs");
+/**
+ * Legacy class-based interface for JSON Schema generation.
+ * This class wraps the new functional implementation to provide backward compatibility.
+ *
+ * @deprecated Use the `toJSONSchema` function instead for new code.
+ *
+ * @example
+ * ```typescript
+ * // Legacy usage (still supported)
+ * const gen = new JSONSchemaGenerator({ target: "draft-07" });
+ * gen.process(schema);
+ * const result = gen.emit(schema);
+ *
+ * // Preferred modern usage
+ * const result = toJSONSchema(schema, { target: "draft-07" });
+ * ```
+ */
+class JSONSchemaGenerator {
+    /** @deprecated Access via ctx instead */
+    get metadataRegistry() {
+        return this.ctx.metadataRegistry;
+    }
+    /** @deprecated Access via ctx instead */
+    get target() {
+        return this.ctx.target;
+    }
+    // annotated so the .d.cts emits an indexed access rather than an inline `import()` of an ESM path
+    /** @deprecated Access via ctx instead */
+    get unrepresentable() {
+        return this.ctx.unrepresentable;
+    }
+    /** @deprecated Access via ctx instead */
+    get override() {
+        return this.ctx.override;
+    }
+    /** @deprecated Access via ctx instead */
+    get io() {
+        return this.ctx.io;
+    }
+    /** @deprecated Access via ctx instead */
+    get counter() {
+        return this.ctx.counter;
+    }
+    set counter(value) {
+        this.ctx.counter = value;
+    }
+    /** @deprecated Access via ctx instead */
+    get seen() {
+        return this.ctx.seen;
+    }
+    constructor(params) {
+        // Normalize target for internal context
+        let normalizedTarget = params?.target ?? "draft-2020-12";
+        if (normalizedTarget === "draft-4")
+            normalizedTarget = "draft-04";
+        if (normalizedTarget === "draft-7")
+            normalizedTarget = "draft-07";
+        this.ctx = (0, to_json_schema_js_1.initializeContext)({
+            processors: json_schema_processors_js_1.allProcessors,
+            target: normalizedTarget,
+            ...(params?.metadata && { metadata: params.metadata }),
+            ...(params?.unrepresentable && { unrepresentable: params.unrepresentable }),
+            ...(params?.override && { override: params.override }),
+            ...(params?.io && { io: params.io }),
+        });
+    }
+    /**
+     * Process a schema to prepare it for JSON Schema generation.
+     * This must be called before emit().
+     */
+    process(schema, _params = { path: [], schemaPath: [] }) {
+        return (0, to_json_schema_js_1.processSchema)(schema, this.ctx, _params);
+    }
+    /**
+     * Emit the final JSON Schema after processing.
+     * Must call process() first.
+     */
+    emit(schema, _params) {
+        // Apply emit params to the context
+        if (_params) {
+            if (_params.cycles)
+                this.ctx.cycles = _params.cycles;
+            if (_params.reused)
+                this.ctx.reused = _params.reused;
+            if (_params.external)
+                this.ctx.external = _params.external;
+        }
+        // extractDefs/finalize skip their whole-map passes when they have already run for this `external`, but they also branch on `cycles`, `reused`, `seen.count` and the metadata registry — any of which can change between emits, including with no params at all. Drop the guards so the passes re-run. The registry conversion calls extractDefs/finalize directly and never routes through here, so it keeps skipping them.
+        this.ctx.sharedDefsExtractedFor = undefined;
+        this.ctx.sharedEmitDoneFor = undefined;
+        (0, to_json_schema_js_1.extractDefs)(this.ctx, schema);
+        const result = (0, to_json_schema_js_1.finalize)(this.ctx, schema);
+        // Strip ~standard property to match old implementation's return type
+        const { "~standard": _, ...plainResult } = result;
+        return plainResult;
+    }
+}
+exports.JSONSchemaGenerator = JSONSchemaGenerator;
+
+// 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/json-schema-generator.d.cts

@@ -0,0 +1,65 @@
+import type * as JSONSchema from "./json-schema.cjs";
+import type { $ZodRegistry } from "./registries.cjs";
+import type * as schemas from "./schemas.cjs";
+import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen, type ToJSONSchemaContext } from "./to-json-schema.cjs";
+/**
+ * Parameters for the emit method of JSONSchemaGenerator.
+ * @deprecated Use toJSONSchema function instead
+ */
+export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
+/**
+ * Parameters for JSONSchemaGenerator constructor.
+ * @deprecated Use toJSONSchema function instead
+ */
+type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
+/**
+ * Legacy class-based interface for JSON Schema generation.
+ * This class wraps the new functional implementation to provide backward compatibility.
+ *
+ * @deprecated Use the `toJSONSchema` function instead for new code.
+ *
+ * @example
+ * ```typescript
+ * // Legacy usage (still supported)
+ * const gen = new JSONSchemaGenerator({ target: "draft-07" });
+ * gen.process(schema);
+ * const result = gen.emit(schema);
+ *
+ * // Preferred modern usage
+ * const result = toJSONSchema(schema, { target: "draft-07" });
+ * ```
+ */
+export declare class JSONSchemaGenerator {
+    private ctx;
+    /** @deprecated Access via ctx instead */
+    get metadataRegistry(): $ZodRegistry<Record<string, any>>;
+    /** @deprecated Access via ctx instead */
+    get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
+    /** @deprecated Access via ctx instead */
+    get unrepresentable(): ToJSONSchemaContext["unrepresentable"];
+    /** @deprecated Access via ctx instead */
+    get override(): (ctx: {
+        zodSchema: schemas.$ZodType;
+        jsonSchema: JSONSchema.BaseSchema;
+        path: (string | number)[];
+    }) => void;
+    /** @deprecated Access via ctx instead */
+    get io(): "input" | "output";
+    /** @deprecated Access via ctx instead */
+    get counter(): number;
+    set counter(value: number);
+    /** @deprecated Access via ctx instead */
+    get seen(): Map<schemas.$ZodType, Seen>;
+    constructor(params?: JSONSchemaGeneratorConstructorParams);
+    /**
+     * Process a schema to prepare it for JSON Schema generation.
+     * This must be called before emit().
+     */
+    process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
+    /**
+     * Emit the final JSON Schema after processing.
+     * Must call process() first.
+     */
+    emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
+}
+export {};

package/node_modules/zod/v4/core/json-schema-generator.d.ts

@@ -0,0 +1,65 @@
+import type * as JSONSchema from "./json-schema.js";
+import type { $ZodRegistry } from "./registries.js";
+import type * as schemas from "./schemas.js";
+import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen, type ToJSONSchemaContext } from "./to-json-schema.js";
+/**
+ * Parameters for the emit method of JSONSchemaGenerator.
+ * @deprecated Use toJSONSchema function instead
+ */
+export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
+/**
+ * Parameters for JSONSchemaGenerator constructor.
+ * @deprecated Use toJSONSchema function instead
+ */
+type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
+/**
+ * Legacy class-based interface for JSON Schema generation.
+ * This class wraps the new functional implementation to provide backward compatibility.
+ *
+ * @deprecated Use the `toJSONSchema` function instead for new code.
+ *
+ * @example
+ * ```typescript
+ * // Legacy usage (still supported)
+ * const gen = new JSONSchemaGenerator({ target: "draft-07" });
+ * gen.process(schema);
+ * const result = gen.emit(schema);
+ *
+ * // Preferred modern usage
+ * const result = toJSONSchema(schema, { target: "draft-07" });
+ * ```
+ */
+export declare class JSONSchemaGenerator {
+    private ctx;
+    /** @deprecated Access via ctx instead */
+    get metadataRegistry(): $ZodRegistry<Record<string, any>>;
+    /** @deprecated Access via ctx instead */
+    get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
+    /** @deprecated Access via ctx instead */
+    get unrepresentable(): ToJSONSchemaContext["unrepresentable"];
+    /** @deprecated Access via ctx instead */
+    get override(): (ctx: {
+        zodSchema: schemas.$ZodType;
+        jsonSchema: JSONSchema.BaseSchema;
+        path: (string | number)[];
+    }) => void;
+    /** @deprecated Access via ctx instead */
+    get io(): "input" | "output";
+    /** @deprecated Access via ctx instead */
+    get counter(): number;
+    set counter(value: number);
+    /** @deprecated Access via ctx instead */
+    get seen(): Map<schemas.$ZodType, Seen>;
+    constructor(params?: JSONSchemaGeneratorConstructorParams);
+    /**
+     * Process a schema to prepare it for JSON Schema generation.
+     * This must be called before emit().
+     */
+    process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
+    /**
+     * Emit the final JSON Schema after processing.
+     * Must call process() first.
+     */
+    emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
+}
+export {};