@ray-js/robot-data-stream 0.0.14 → 0.0.15-beta.1

package/lib/myLib/zod/src/v4/core/to-json-schema.js

@@ -0,0 +1,488 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { globalRegistry } from "./registries.js";
+
+/**
+ * Parameters for the toJSONSchema function.
+ */
+
+/**
+ * Parameters for the toJSONSchema function when passing a registry.
+ */
+
+// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
+//   return {
+//     processor: inputs.processor,
+//     metadataRegistry: inputs.metadata ?? globalRegistry,
+//     target: inputs.target ?? "draft-2020-12",
+//     unrepresentable: inputs.unrepresentable ?? "throw",
+//   };
+// }
+
+export function initializeContext(params) {
+  var _params$target, _params$processors, _params$metadata, _params$unrepresentab, _ref, _params$io, _params$cycles, _params$reused, _params$external;
+  // Normalize target: convert old non-hyphenated versions to hyphenated versions
+  let target = (_params$target = params === null || params === void 0 ? void 0 : params.target) !== null && _params$target !== void 0 ? _params$target : "draft-2020-12";
+  if (target === "draft-4") target = "draft-04";
+  if (target === "draft-7") target = "draft-07";
+  return {
+    processors: (_params$processors = params.processors) !== null && _params$processors !== void 0 ? _params$processors : {},
+    metadataRegistry: (_params$metadata = params === null || params === void 0 ? void 0 : params.metadata) !== null && _params$metadata !== void 0 ? _params$metadata : globalRegistry,
+    target,
+    unrepresentable: (_params$unrepresentab = params === null || params === void 0 ? void 0 : params.unrepresentable) !== null && _params$unrepresentab !== void 0 ? _params$unrepresentab : "throw",
+    override: (_ref = params === null || params === void 0 ? void 0 : params.override) !== null && _ref !== void 0 ? _ref : () => {},
+    io: (_params$io = params === null || params === void 0 ? void 0 : params.io) !== null && _params$io !== void 0 ? _params$io : "output",
+    counter: 0,
+    seen: new Map(),
+    cycles: (_params$cycles = params === null || params === void 0 ? void 0 : params.cycles) !== null && _params$cycles !== void 0 ? _params$cycles : "ref",
+    reused: (_params$reused = params === null || params === void 0 ? void 0 : params.reused) !== null && _params$reused !== void 0 ? _params$reused : "inline",
+    external: (_params$external = params === null || params === void 0 ? void 0 : params.external) !== null && _params$external !== void 0 ? _params$external : undefined
+  };
+}
+export function process(schema, ctx) {
+  var _schema$_zod$toJSONSc, _schema$_zod;
+  let _params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    path: [],
+    schemaPath: []
+  };
+  const def = schema._zod.def;
+
+  // check for schema in seens
+  const seen = ctx.seen.get(schema);
+  if (seen) {
+    seen.count++;
+
+    // check if cycle
+    const isCycle = _params.schemaPath.includes(schema);
+    if (isCycle) {
+      seen.cycle = _params.path;
+    }
+    return seen.schema;
+  }
+
+  // initialize
+  const result = {
+    schema: {},
+    count: 1,
+    cycle: undefined,
+    path: _params.path
+  };
+  ctx.seen.set(schema, result);
+
+  // custom method overrides default behavior
+  const overrideSchema = (_schema$_zod$toJSONSc = (_schema$_zod = schema._zod).toJSONSchema) === null || _schema$_zod$toJSONSc === void 0 ? void 0 : _schema$_zod$toJSONSc.call(_schema$_zod);
+  if (overrideSchema) {
+    result.schema = overrideSchema;
+  } else {
+    const params = _objectSpread(_objectSpread({}, _params), {}, {
+      schemaPath: [..._params.schemaPath, schema],
+      path: _params.path
+    });
+    if (schema._zod.processJSONSchema) {
+      schema._zod.processJSONSchema(ctx, result.schema, params);
+    } else {
+      const _json = result.schema;
+      const processor = ctx.processors[def.type];
+      if (!processor) {
+        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+      }
+      processor(schema, ctx, _json, params);
+    }
+    const parent = schema._zod.parent;
+    if (parent) {
+      // Also set ref if processor didn't (for inheritance)
+      if (!result.ref) result.ref = parent;
+      process(parent, ctx, params);
+      ctx.seen.get(parent).isParent = true;
+    }
+  }
+
+  // metadata
+  const meta = ctx.metadataRegistry.get(schema);
+  if (meta) Object.assign(result.schema, meta);
+  if (ctx.io === "input" && isTransforming(schema)) {
+    // examples/defaults only apply to output type of pipe
+    delete result.schema.examples;
+    delete result.schema.default;
+  }
+
+  // set prefault as default
+  if (ctx.io === "input" && result.schema._prefault) result.schema.default ??= result.schema._prefault;
+  delete result.schema._prefault;
+
+  // pulling fresh from ctx.seen in case it was overwritten
+  const _result = ctx.seen.get(schema);
+  return _result.schema;
+}
+export function extractDefs(ctx, schema) {
+  // iterate over seen map;
+  const root = ctx.seen.get(schema);
+  if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+
+  // Track ids to detect duplicates across different schemas
+  const idToSchema = new Map();
+  for (const entry of ctx.seen.entries()) {
+    var _ctx$metadataRegistry;
+    const id = (_ctx$metadataRegistry = ctx.metadataRegistry.get(entry[0])) === null || _ctx$metadataRegistry === void 0 ? void 0 : _ctx$metadataRegistry.id;
+    if (id) {
+      const existing = idToSchema.get(id);
+      if (existing && existing !== entry[0]) {
+        throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+      }
+      idToSchema.set(id, entry[0]);
+    }
+  }
+
+  // returns a ref to the schema
+  // defId will be empty if the ref points to an external schema (or #)
+  const makeURI = entry => {
+    var _entry$1$schema$id;
+    // comparing the seen objects because sometimes
+    // multiple schemas map to the same seen object.
+    // e.g. lazy
+
+    // external is configured
+    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+    if (ctx.external) {
+      var _ctx$external$registr, _ctx$external$uri, _ref2, _entry$1$defId;
+      const externalId = (_ctx$external$registr = ctx.external.registry.get(entry[0])) === null || _ctx$external$registr === void 0 ? void 0 : _ctx$external$registr.id; // ?? "__shared";// `__schema${ctx.counter++}`;
+
+      // check if schema is in the external registry
+      const uriGenerator = (_ctx$external$uri = ctx.external.uri) !== null && _ctx$external$uri !== void 0 ? _ctx$external$uri : id => id;
+      if (externalId) {
+        return {
+          ref: uriGenerator(externalId)
+        };
+      }
+
+      // otherwise, add to __shared
+      const id = (_ref2 = (_entry$1$defId = entry[1].defId) !== null && _entry$1$defId !== void 0 ? _entry$1$defId : entry[1].schema.id) !== null && _ref2 !== void 0 ? _ref2 : `schema${ctx.counter++}`;
+      entry[1].defId = id; // set defId so it will be reused if needed
+      return {
+        defId: id,
+        ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}`
+      };
+    }
+    if (entry[1] === root) {
+      return {
+        ref: "#"
+      };
+    }
+
+    // self-contained schema
+
+    const defId = (_entry$1$schema$id = entry[1].schema.id) !== null && _entry$1$schema$id !== void 0 ? _entry$1$schema$id : `__schema${ctx.counter++}`;
+    return {
+      defId,
+      ref: `${`#`}/${defsSegment}/` + defId
+    };
+  };
+
+  // stored cached version in `def` property
+  // remove all properties, set $ref
+  const extractToDef = entry => {
+    // if the schema is already a reference, do not extract it
+    if (entry[1].schema.$ref) {
+      return;
+    }
+    const seen = entry[1];
+    const {
+      ref,
+      defId
+    } = makeURI(entry);
+    seen.def = _objectSpread({}, seen.schema);
+    // defId won't be set if the schema is a reference to an external schema
+    // or if the schema is the root schema
+    if (defId) seen.defId = defId;
+    // wipe away all properties except $ref
+    const schema = seen.schema;
+    for (const key in schema) {
+      delete schema[key];
+    }
+    schema.$ref = ref;
+  };
+
+  // throw on cycles
+
+  // break cycles
+  if (ctx.cycles === "throw") {
+    for (const entry of ctx.seen.entries()) {
+      const seen = entry[1];
+      if (seen.cycle) {
+        var _seen$cycle;
+        throw new Error("Cycle detected: " + `#/${(_seen$cycle = seen.cycle) === null || _seen$cycle === void 0 ? void 0 : _seen$cycle.join("/")}/<root>` + '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
+      }
+    }
+  }
+
+  // extract schemas into $defs
+  for (const entry of ctx.seen.entries()) {
+    var _ctx$metadataRegistry2;
+    const seen = entry[1];
+
+    // convert root schema to # $ref
+    if (schema === entry[0]) {
+      extractToDef(entry); // this has special handling for the root schema
+      continue;
+    }
+
+    // extract schemas that are in the external registry
+    if (ctx.external) {
+      var _ctx$external$registr2;
+      const ext = (_ctx$external$registr2 = ctx.external.registry.get(entry[0])) === null || _ctx$external$registr2 === void 0 ? void 0 : _ctx$external$registr2.id;
+      if (schema !== entry[0] && ext) {
+        extractToDef(entry);
+        continue;
+      }
+    }
+
+    // extract schemas with `id` meta
+    const id = (_ctx$metadataRegistry2 = ctx.metadataRegistry.get(entry[0])) === null || _ctx$metadataRegistry2 === void 0 ? void 0 : _ctx$metadataRegistry2.id;
+    if (id) {
+      extractToDef(entry);
+      continue;
+    }
+
+    // break cycles
+    if (seen.cycle) {
+      // any
+      extractToDef(entry);
+      continue;
+    }
+
+    // extract reused schemas
+    if (seen.count > 1) {
+      if (ctx.reused === "ref") {
+        extractToDef(entry);
+        // biome-ignore lint:
+        continue;
+      }
+    }
+  }
+}
+export function finalize(ctx, schema) {
+  var _ctx$external, _root$def, _ctx$external$defs, _ctx$external2;
+  const root = ctx.seen.get(schema);
+  if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+
+  // flatten refs - inherit properties from parent schemas
+  const flattenRef = zodSchema => {
+    var _seen$def, _seen$path;
+    const seen = ctx.seen.get(zodSchema);
+
+    // already processed
+    if (seen.ref === null) return;
+    const schema = (_seen$def = seen.def) !== null && _seen$def !== void 0 ? _seen$def : seen.schema;
+    const _cached = _objectSpread({}, schema);
+    const ref = seen.ref;
+    seen.ref = null; // prevent infinite recursion
+
+    if (ref) {
+      flattenRef(ref);
+      const refSeen = ctx.seen.get(ref);
+      const refSchema = refSeen.schema;
+
+      // merge referenced schema into current
+      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+        var _schema$allOf;
+        // older drafts can't combine $ref with other properties
+        schema.allOf = (_schema$allOf = schema.allOf) !== null && _schema$allOf !== void 0 ? _schema$allOf : [];
+        schema.allOf.push(refSchema);
+      } else {
+        Object.assign(schema, refSchema);
+      }
+      // restore child's own properties (child wins)
+      Object.assign(schema, _cached);
+      const isParentRef = zodSchema._zod.parent === ref;
+
+      // For parent chain, child is a refinement - remove parent-only properties
+      if (isParentRef) {
+        for (const key in schema) {
+          if (key === "$ref" || key === "allOf") continue;
+          if (!(key in _cached)) {
+            delete schema[key];
+          }
+        }
+      }
+
+      // When ref was extracted to $defs, remove properties that match the definition
+      if (refSchema.$ref) {
+        for (const key in schema) {
+          if (key === "$ref" || key === "allOf") continue;
+          if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema[key];
+          }
+        }
+      }
+    }
+
+    // If parent was extracted (has $ref), propagate $ref to this schema
+    // This handles cases like: readonly().meta({id}).describe()
+    // where processor sets ref to innerType but parent should be referenced
+    const parent = zodSchema._zod.parent;
+    if (parent && parent !== ref) {
+      // Ensure parent is processed first so its def has inherited properties
+      flattenRef(parent);
+      const parentSeen = ctx.seen.get(parent);
+      if (parentSeen !== null && parentSeen !== void 0 && parentSeen.schema.$ref) {
+        schema.$ref = parentSeen.schema.$ref;
+        // De-duplicate with parent's definition
+        if (parentSeen.def) {
+          for (const key in schema) {
+            if (key === "$ref" || key === "allOf") continue;
+            if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema[key];
+            }
+          }
+        }
+      }
+    }
+
+    // execute overrides
+    ctx.override({
+      zodSchema: zodSchema,
+      jsonSchema: schema,
+      path: (_seen$path = seen.path) !== null && _seen$path !== void 0 ? _seen$path : []
+    });
+  };
+  for (const entry of [...ctx.seen.entries()].reverse()) {
+    flattenRef(entry[0]);
+  }
+  const result = {};
+  if (ctx.target === "draft-2020-12") {
+    result.$schema = "https://json-schema.org/draft/2020-12/schema";
+  } else if (ctx.target === "draft-07") {
+    result.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (ctx.target === "draft-04") {
+    result.$schema = "http://json-schema.org/draft-04/schema#";
+  } else if (ctx.target === "openapi-3.0") {
+    // OpenAPI 3.0 schema objects should not include a $schema property
+  }
+  if ((_ctx$external = ctx.external) !== null && _ctx$external !== void 0 && _ctx$external.uri) {
+    var _ctx$external$registr3;
+    const id = (_ctx$external$registr3 = ctx.external.registry.get(schema)) === null || _ctx$external$registr3 === void 0 ? void 0 : _ctx$external$registr3.id;
+    if (!id) throw new Error("Schema is missing an `id` property");
+    result.$id = ctx.external.uri(id);
+  }
+  Object.assign(result, (_root$def = root.def) !== null && _root$def !== void 0 ? _root$def : root.schema);
+
+  // build defs object
+  const defs = (_ctx$external$defs = (_ctx$external2 = ctx.external) === null || _ctx$external2 === void 0 ? void 0 : _ctx$external2.defs) !== null && _ctx$external$defs !== void 0 ? _ctx$external$defs : {};
+  for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
+    if (seen.def && seen.defId) {
+      defs[seen.defId] = seen.def;
+    }
+  }
+
+  // set definitions in result
+  if (!ctx.external) {
+    if (Object.keys(defs).length > 0) {
+      if (ctx.target === "draft-2020-12") {
+        result.$defs = defs;
+      } else {
+        result.definitions = defs;
+      }
+    }
+  }
+  try {
+    // this "finalizes" this schema and ensures all cycles are removed
+    // each call to finalize() is functionally independent
+    // though the seen map is shared
+    const finalized = JSON.parse(JSON.stringify(result));
+    Object.defineProperty(finalized, "~standard", {
+      value: _objectSpread(_objectSpread({}, schema["~standard"]), {}, {
+        jsonSchema: {
+          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+        }
+      }),
+      enumerable: false,
+      writable: false
+    });
+    return finalized;
+  } catch (_err) {
+    throw new Error("Error converting schema to JSON.");
+  }
+}
+function isTransforming(_schema, _ctx) {
+  const ctx = _ctx !== null && _ctx !== void 0 ? _ctx : {
+    seen: new Set()
+  };
+  if (ctx.seen.has(_schema)) return false;
+  ctx.seen.add(_schema);
+  const def = _schema._zod.def;
+  if (def.type === "transform") return true;
+  if (def.type === "array") return isTransforming(def.element, ctx);
+  if (def.type === "set") return isTransforming(def.valueType, ctx);
+  if (def.type === "lazy") return isTransforming(def.getter(), ctx);
+  if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
+    return isTransforming(def.innerType, ctx);
+  }
+  if (def.type === "intersection") {
+    return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+  }
+  if (def.type === "record" || def.type === "map") {
+    return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+  }
+  if (def.type === "pipe") {
+    return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+  }
+  if (def.type === "object") {
+    for (const key in def.shape) {
+      if (isTransforming(def.shape[key], ctx)) return true;
+    }
+    return false;
+  }
+  if (def.type === "union") {
+    for (const option of def.options) {
+      if (isTransforming(option, ctx)) return true;
+    }
+    return false;
+  }
+  if (def.type === "tuple") {
+    for (const item of def.items) {
+      if (isTransforming(item, ctx)) return true;
+    }
+    if (def.rest && isTransforming(def.rest, ctx)) return true;
+    return false;
+  }
+  return false;
+}
+/**
+ * Creates a toJSONSchema method for a schema instance.
+ * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+ */
+export const createToJSONSchemaMethod = function (schema) {
+  let processors = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return params => {
+    const ctx = initializeContext(_objectSpread(_objectSpread({}, params), {}, {
+      processors
+    }));
+    process(schema, ctx);
+    extractDefs(ctx, schema);
+    return finalize(ctx, schema);
+  };
+};
+
+/**
+ * Creates a toJSONSchema method for a schema instance.
+ * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+ */
+
+export const createStandardJSONSchemaMethod = function (schema, io) {
+  let processors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return params => {
+    const {
+      libraryOptions,
+      target
+    } = params !== null && params !== void 0 ? params : {};
+    const ctx = initializeContext(_objectSpread(_objectSpread({}, libraryOptions !== null && libraryOptions !== void 0 ? libraryOptions : {}), {}, {
+      target,
+      io,
+      processors
+    }));
+    process(schema, ctx);
+    extractDefs(ctx, schema);
+    return finalize(ctx, schema);
+  };
+};

package/lib/myLib/zod/src/v4/core/util.d.ts

@@ -0,0 +1,199 @@
+import type * as checks from "./checks.js";
+import type { $ZodConfig } from "./core.js";
+import type * as errors from "./errors.js";
+import type * as schemas from "./schemas.js";
+export type JSONType = string | number | boolean | null | JSONType[] | {
+    [key: string]: JSONType;
+};
+export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
+export type HashEncoding = "hex" | "base64" | "base64url";
+export type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
+export type IPVersion = "v4" | "v6";
+export type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
+export type ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
+export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
+export type AssertExtends<T, U> = T extends U ? T : never;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+export type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;
+export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+export type NoUndefined<T> = T extends undefined ? never : T;
+export type Whatever = {} | undefined | null;
+export type LoosePartial<T extends object> = InexactPartial<T> & {
+    [k: string]: unknown;
+};
+export type Mask<Keys extends PropertyKey> = {
+    [K in Keys]?: true;
+};
+export type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+} & {};
+export type InexactPartial<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+export type EmptyObject = Record<string, never>;
+export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+    readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+export type SomeObject = Record<PropertyKey, any>;
+export type Identity<T> = T;
+export type Flatten<T> = Identity<{
+    [k in keyof T]: T[k];
+}>;
+export type Mapped<T> = {
+    [k in keyof T]: T[k];
+};
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type NoNeverKeys<T> = {
+    [k in keyof T]: [T[k]] extends [never] ? never : k;
+}[keyof T];
+export type NoNever<T> = Identity<{
+    [k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
+}>;
+export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {
+    [K in keyof A as K extends keyof B ? never : K]: A[K];
+} & {
+    [K in keyof B]: B[K];
+}>;
+export type TupleItems = ReadonlyArray<schemas.SomeType>;
+export type AnyFunc = (...args: any[]) => any;
+export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
+export type MaybeAsync<T> = T | Promise<T>;
+export type KeyOf<T> = keyof OmitIndexSignature<T>;
+export type OmitIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
+};
+export type ExtractIndexSignature<T> = {
+    [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
+};
+export type Keys<T extends object> = keyof OmitIndexSignature<T>;
+export type SchemaClass<T extends schemas.SomeType> = {
+    new (def: T["_zod"]["def"]): T;
+};
+export type EnumValue = string | number;
+export type EnumLike = Readonly<Record<string, EnumValue>>;
+export type ToEnum<T extends EnumValue> = Flatten<{
+    [k in T]: k;
+}>;
+export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
+export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
+export type Literal = string | number | bigint | boolean | null | undefined;
+export type LiteralArray = Array<Literal>;
+export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+export type PrimitiveArray = Array<Primitive>;
+export type HasSize = {
+    size: number;
+};
+export type HasLength = {
+    length: number;
+};
+export type Numeric = number | bigint | Date;
+export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
+export type SafeParseSuccess<T> = {
+    success: true;
+    data: T;
+    error?: never;
+};
+export type SafeParseError<T> = {
+    success: false;
+    data?: never;
+    error: errors.$ZodError<T>;
+};
+export type PropValues = Record<string, Set<Primitive>>;
+export type PrimitiveSet = Set<Primitive>;
+export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
+export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
+export declare function assertIs<T>(_arg: T): void;
+export declare function assertNever(_x: never): never;
+export declare function assert<T>(_: any): asserts _ is T;
+export declare function getEnumValues(entries: EnumLike): EnumValue[];
+export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
+export declare function jsonStringifyReplacer(_: string, value: any): any;
+export declare function cached<T>(getter: () => T): {
+    value: T;
+};
+export declare function nullish(input: any): boolean;
+export declare function cleanRegex(source: string): string;
+export declare function floatSafeRemainder(val: number, step: number): number;
+export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
+export declare function objectClone(obj: object): any;
+export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
+export declare function mergeDefs(...defs: Record<string, any>[]): any;
+export declare function cloneDef(schema: schemas.$ZodType): any;
+export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
+export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
+    [k in keyof T]: Awaited<T[k]>;
+}>;
+export declare function randomString(length?: number): string;
+export declare function esc(str: string): string;
+export declare function slugify(input: string): string;
+export declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
+export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
+export declare const allowsEval: {
+    value: boolean;
+};
+export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
+export declare function shallowClone(o: any): any;
+export declare function numKeys(data: any): number;
+export declare const getParsedType: (data: any) => ParsedTypes;
+export declare const propertyKeyTypes: Set<string>;
+export declare const primitiveTypes: Set<string>;
+export declare function escapeRegex(str: string): string;
+export declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
+    parent: boolean;
+}): T;
+export type EmptyToNever<T> = keyof T extends never ? never : T;
+export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
+    [k in keyof Omit<T, "error" | "message">]: T[k];
+} & ("error" extends keyof T ? {
+    error?: Exclude<T["error"], string>;
+} : unknown)> : never;
+export declare function normalizeParams<T>(_params: T): Normalize<T>;
+export declare function createTransparentProxy<T extends object>(getter: () => T): T;
+export declare function stringifyPrimitive(value: any): string;
+export declare function optionalKeys(shape: schemas.$ZodShape): string[];
+export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
+export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
+    [k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
+};
+export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
+    [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
+};
+export declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;
+export declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;
+export declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
+export declare function omit(schema: schemas.$ZodObject, mask: object): any;
+export declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
+export declare function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
+export declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
+export declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined): any;
+export declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
+export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
+export declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
+export declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];
+export declare function unwrapMessage(message: string | {
+    message: string;
+} | undefined | null): string | undefined;
+export declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;
+export declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
+export declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
+export declare function parsedType(data: unknown): errors.$ZodInvalidTypeExpected;
+export declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
+export declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
+export declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
+export declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;
+export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
+export declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;
+export declare function uint8ArrayToBase64url(bytes: Uint8Array): string;
+export declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;
+export declare function uint8ArrayToHex(bytes: Uint8Array): string;
+export declare abstract class Class {
+    constructor(..._args: any[]);
+}