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

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

@@ -0,0 +1,593 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.every.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.map.js";
+import { extractDefs, finalize, initializeContext, process } from "./to-json-schema.js";
+import { getEnumValues } from "./util.js";
+const formatMap = {
+  guid: "uuid",
+  url: "uri",
+  datetime: "date-time",
+  json_string: "json-string",
+  regex: "" // do not set
+};
+
+// ==================== SIMPLE TYPE PROCESSORS ====================
+
+export const stringProcessor = (schema, ctx, _json) => {
+  const json = _json;
+  json.type = "string";
+  const {
+    minimum,
+    maximum,
+    format,
+    patterns,
+    contentEncoding
+  } = schema._zod.bag;
+  if (typeof minimum === "number") json.minLength = minimum;
+  if (typeof maximum === "number") json.maxLength = maximum;
+  // custom pattern overrides format
+  if (format) {
+    var _formatMap;
+    json.format = (_formatMap = formatMap[format]) !== null && _formatMap !== void 0 ? _formatMap : format;
+    if (json.format === "") delete json.format; // empty format is not valid
+
+    // JSON Schema format: "time" requires a full time with offset or Z
+    // z.iso.time() does not include timezone information, so format: "time" should never be used
+    if (format === "time") {
+      delete json.format;
+    }
+  }
+  if (contentEncoding) json.contentEncoding = contentEncoding;
+  if (patterns && patterns.size > 0) {
+    const regexes = [...patterns];
+    if (regexes.length === 1) json.pattern = regexes[0].source;else if (regexes.length > 1) {
+      json.allOf = [...regexes.map(regex => _objectSpread(_objectSpread({}, ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? {
+        type: "string"
+      } : {}), {}, {
+        pattern: regex.source
+      }))];
+    }
+  }
+};
+export const numberProcessor = (schema, ctx, _json) => {
+  const json = _json;
+  const {
+    minimum,
+    maximum,
+    format,
+    multipleOf,
+    exclusiveMaximum,
+    exclusiveMinimum
+  } = schema._zod.bag;
+  if (typeof format === "string" && format.includes("int")) json.type = "integer";else json.type = "number";
+  if (typeof exclusiveMinimum === "number") {
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+      json.minimum = exclusiveMinimum;
+      json.exclusiveMinimum = true;
+    } else {
+      json.exclusiveMinimum = exclusiveMinimum;
+    }
+  }
+  if (typeof minimum === "number") {
+    json.minimum = minimum;
+    if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
+      if (exclusiveMinimum >= minimum) delete json.minimum;else delete json.exclusiveMinimum;
+    }
+  }
+  if (typeof exclusiveMaximum === "number") {
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+      json.maximum = exclusiveMaximum;
+      json.exclusiveMaximum = true;
+    } else {
+      json.exclusiveMaximum = exclusiveMaximum;
+    }
+  }
+  if (typeof maximum === "number") {
+    json.maximum = maximum;
+    if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
+      if (exclusiveMaximum <= maximum) delete json.maximum;else delete json.exclusiveMaximum;
+    }
+  }
+  if (typeof multipleOf === "number") json.multipleOf = multipleOf;
+};
+export const booleanProcessor = (_schema, _ctx, json) => {
+  json.type = "boolean";
+};
+export const bigintProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("BigInt cannot be represented in JSON Schema");
+  }
+};
+export const symbolProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Symbols cannot be represented in JSON Schema");
+  }
+};
+export const nullProcessor = (_schema, ctx, json) => {
+  if (ctx.target === "openapi-3.0") {
+    json.type = "string";
+    json.nullable = true;
+    json.enum = [null];
+  } else {
+    json.type = "null";
+  }
+};
+export const undefinedProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Undefined cannot be represented in JSON Schema");
+  }
+};
+export const voidProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Void cannot be represented in JSON Schema");
+  }
+};
+export const neverProcessor = (_schema, _ctx, json) => {
+  json.not = {};
+};
+export const anyProcessor = () => {
+  // empty schema accepts anything
+};
+export const unknownProcessor = () => {
+  // empty schema accepts anything
+};
+export const dateProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Date cannot be represented in JSON Schema");
+  }
+};
+export const enumProcessor = (schema, _ctx, json) => {
+  const def = schema._zod.def;
+  const values = getEnumValues(def.entries);
+  // Number enums can have both string and number values
+  if (values.every(v => typeof v === "number")) json.type = "number";
+  if (values.every(v => typeof v === "string")) json.type = "string";
+  json.enum = values;
+};
+export const literalProcessor = (schema, ctx, json) => {
+  const def = schema._zod.def;
+  const vals = [];
+  for (const val of def.values) {
+    if (val === undefined) {
+      if (ctx.unrepresentable === "throw") {
+        throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+      }
+    } else if (typeof val === "bigint") {
+      if (ctx.unrepresentable === "throw") {
+        throw new Error("BigInt literals cannot be represented in JSON Schema");
+      } else {
+        vals.push(Number(val));
+      }
+    } else {
+      vals.push(val);
+    }
+  }
+  if (vals.length === 0) {
+    // do nothing (an undefined literal was stripped)
+  } else if (vals.length === 1) {
+    const val = vals[0];
+    json.type = val === null ? "null" : typeof val;
+    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+      json.enum = [val];
+    } else {
+      json.const = val;
+    }
+  } else {
+    if (vals.every(v => typeof v === "number")) json.type = "number";
+    if (vals.every(v => typeof v === "string")) json.type = "string";
+    if (vals.every(v => typeof v === "boolean")) json.type = "boolean";
+    if (vals.every(v => v === null)) json.type = "null";
+    json.enum = vals;
+  }
+};
+export const nanProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("NaN cannot be represented in JSON Schema");
+  }
+};
+export const templateLiteralProcessor = (schema, _ctx, json) => {
+  const _json = json;
+  const pattern = schema._zod.pattern;
+  if (!pattern) throw new Error("Pattern not found in template literal");
+  _json.type = "string";
+  _json.pattern = pattern.source;
+};
+export const fileProcessor = (schema, _ctx, json) => {
+  const _json = json;
+  const file = {
+    type: "string",
+    format: "binary",
+    contentEncoding: "binary"
+  };
+  const {
+    minimum,
+    maximum,
+    mime
+  } = schema._zod.bag;
+  if (minimum !== undefined) file.minLength = minimum;
+  if (maximum !== undefined) file.maxLength = maximum;
+  if (mime) {
+    if (mime.length === 1) {
+      file.contentMediaType = mime[0];
+      Object.assign(_json, file);
+    } else {
+      Object.assign(_json, file); // shared props at root
+      _json.anyOf = mime.map(m => ({
+        contentMediaType: m
+      })); // only contentMediaType differs
+    }
+  } else {
+    Object.assign(_json, file);
+  }
+};
+export const successProcessor = (_schema, _ctx, json) => {
+  json.type = "boolean";
+};
+export const customProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Custom types cannot be represented in JSON Schema");
+  }
+};
+export const functionProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Function types cannot be represented in JSON Schema");
+  }
+};
+export const transformProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Transforms cannot be represented in JSON Schema");
+  }
+};
+export const mapProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Map cannot be represented in JSON Schema");
+  }
+};
+export const setProcessor = (_schema, ctx) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Set cannot be represented in JSON Schema");
+  }
+};
+
+// ==================== COMPOSITE TYPE PROCESSORS ====================
+
+export const arrayProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  const {
+    minimum,
+    maximum
+  } = schema._zod.bag;
+  if (typeof minimum === "number") json.minItems = minimum;
+  if (typeof maximum === "number") json.maxItems = maximum;
+  json.type = "array";
+  json.items = process(def.element, ctx, _objectSpread(_objectSpread({}, params), {}, {
+    path: [...params.path, "items"]
+  }));
+};
+export const objectProcessor = (schema, ctx, _json, params) => {
+  var _def$catchall;
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "object";
+  json.properties = {};
+  const shape = def.shape;
+  for (const key in shape) {
+    json.properties[key] = process(shape[key], ctx, _objectSpread(_objectSpread({}, params), {}, {
+      path: [...params.path, "properties", key]
+    }));
+  }
+
+  // required keys
+  const allKeys = new Set(Object.keys(shape));
+  const requiredKeys = new Set([...allKeys].filter(key => {
+    const v = def.shape[key]._zod;
+    if (ctx.io === "input") {
+      return v.optin === undefined;
+    } else {
+      return v.optout === undefined;
+    }
+  }));
+  if (requiredKeys.size > 0) {
+    json.required = Array.from(requiredKeys);
+  }
+
+  // catchall
+  if (((_def$catchall = def.catchall) === null || _def$catchall === void 0 ? void 0 : _def$catchall._zod.def.type) === "never") {
+    // strict
+    json.additionalProperties = false;
+  } else if (!def.catchall) {
+    // regular
+    if (ctx.io === "output") json.additionalProperties = false;
+  } else if (def.catchall) {
+    json.additionalProperties = process(def.catchall, ctx, _objectSpread(_objectSpread({}, params), {}, {
+      path: [...params.path, "additionalProperties"]
+    }));
+  }
+};
+export const unionProcessor = (schema, ctx, json, params) => {
+  const def = schema._zod.def;
+  // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
+  // This includes both z.xor() and discriminated unions
+  const isExclusive = def.inclusive === false;
+  const options = def.options.map((x, i) => process(x, ctx, _objectSpread(_objectSpread({}, params), {}, {
+    path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
+  })));
+  if (isExclusive) {
+    json.oneOf = options;
+  } else {
+    json.anyOf = options;
+  }
+};
+export const intersectionProcessor = (schema, ctx, json, params) => {
+  const def = schema._zod.def;
+  const a = process(def.left, ctx, _objectSpread(_objectSpread({}, params), {}, {
+    path: [...params.path, "allOf", 0]
+  }));
+  const b = process(def.right, ctx, _objectSpread(_objectSpread({}, params), {}, {
+    path: [...params.path, "allOf", 1]
+  }));
+  const isSimpleIntersection = val => "allOf" in val && Object.keys(val).length === 1;
+  const allOf = [...(isSimpleIntersection(a) ? a.allOf : [a]), ...(isSimpleIntersection(b) ? b.allOf : [b])];
+  json.allOf = allOf;
+};
+export const tupleProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "array";
+  const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+  const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+  const prefixItems = def.items.map((x, i) => process(x, ctx, _objectSpread(_objectSpread({}, params), {}, {
+    path: [...params.path, prefixPath, i]
+  })));
+  const rest = def.rest ? process(def.rest, ctx, _objectSpread(_objectSpread({}, params), {}, {
+    path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])]
+  })) : null;
+  if (ctx.target === "draft-2020-12") {
+    json.prefixItems = prefixItems;
+    if (rest) {
+      json.items = rest;
+    }
+  } else if (ctx.target === "openapi-3.0") {
+    json.items = {
+      anyOf: prefixItems
+    };
+    if (rest) {
+      json.items.anyOf.push(rest);
+    }
+    json.minItems = prefixItems.length;
+    if (!rest) {
+      json.maxItems = prefixItems.length;
+    }
+  } else {
+    json.items = prefixItems;
+    if (rest) {
+      json.additionalItems = rest;
+    }
+  }
+
+  // length
+  const {
+    minimum,
+    maximum
+  } = schema._zod.bag;
+  if (typeof minimum === "number") json.minItems = minimum;
+  if (typeof maximum === "number") json.maxItems = maximum;
+};
+export const recordProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "object";
+
+  // For looseRecord with regex patterns, use patternProperties
+  // This correctly represents "only validate keys matching the pattern" semantics
+  // and composes well with allOf (intersections)
+  const keyType = def.keyType;
+  const keyBag = keyType._zod.bag;
+  const patterns = keyBag === null || keyBag === void 0 ? void 0 : keyBag.patterns;
+  if (def.mode === "loose" && patterns && patterns.size > 0) {
+    // Use patternProperties for looseRecord with regex patterns
+    const valueSchema = process(def.valueType, ctx, _objectSpread(_objectSpread({}, params), {}, {
+      path: [...params.path, "patternProperties", "*"]
+    }));
+    json.patternProperties = {};
+    for (const pattern of patterns) {
+      json.patternProperties[pattern.source] = valueSchema;
+    }
+  } else {
+    // Default behavior: use propertyNames + additionalProperties
+    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+      json.propertyNames = process(def.keyType, ctx, _objectSpread(_objectSpread({}, params), {}, {
+        path: [...params.path, "propertyNames"]
+      }));
+    }
+    json.additionalProperties = process(def.valueType, ctx, _objectSpread(_objectSpread({}, params), {}, {
+      path: [...params.path, "additionalProperties"]
+    }));
+  }
+
+  // Add required for keys with discrete values (enum, literal, etc.)
+  const keyValues = keyType._zod.values;
+  if (keyValues) {
+    const validKeyValues = [...keyValues].filter(v => typeof v === "string" || typeof v === "number");
+    if (validKeyValues.length > 0) {
+      json.required = validKeyValues;
+    }
+  }
+};
+export const nullableProcessor = (schema, ctx, json, params) => {
+  const def = schema._zod.def;
+  const inner = process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  if (ctx.target === "openapi-3.0") {
+    seen.ref = def.innerType;
+    json.nullable = true;
+  } else {
+    json.anyOf = [inner, {
+      type: "null"
+    }];
+  }
+};
+export const nonoptionalProcessor = (schema, ctx, _json, params) => {
+  const def = schema._zod.def;
+  process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+};
+export const defaultProcessor = (schema, ctx, json, params) => {
+  const def = schema._zod.def;
+  process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+  json.default = JSON.parse(JSON.stringify(def.defaultValue));
+};
+export const prefaultProcessor = (schema, ctx, json, params) => {
+  const def = schema._zod.def;
+  process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+  if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+};
+export const catchProcessor = (schema, ctx, json, params) => {
+  const def = schema._zod.def;
+  process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+  let catchValue;
+  try {
+    catchValue = def.catchValue(undefined);
+  } catch {
+    throw new Error("Dynamic catch values are not supported in JSON Schema");
+  }
+  json.default = catchValue;
+};
+export const pipeProcessor = (schema, ctx, _json, params) => {
+  const def = schema._zod.def;
+  const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
+  process(innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = innerType;
+};
+export const readonlyProcessor = (schema, ctx, json, params) => {
+  const def = schema._zod.def;
+  process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+  json.readOnly = true;
+};
+export const promiseProcessor = (schema, ctx, _json, params) => {
+  const def = schema._zod.def;
+  process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+};
+export const optionalProcessor = (schema, ctx, _json, params) => {
+  const def = schema._zod.def;
+  process(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+};
+export const lazyProcessor = (schema, ctx, _json, params) => {
+  const innerType = schema._zod.innerType;
+  process(innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = innerType;
+};
+
+// ==================== ALL PROCESSORS ====================
+
+export const allProcessors = {
+  string: stringProcessor,
+  number: numberProcessor,
+  boolean: booleanProcessor,
+  bigint: bigintProcessor,
+  symbol: symbolProcessor,
+  null: nullProcessor,
+  undefined: undefinedProcessor,
+  void: voidProcessor,
+  never: neverProcessor,
+  any: anyProcessor,
+  unknown: unknownProcessor,
+  date: dateProcessor,
+  enum: enumProcessor,
+  literal: literalProcessor,
+  nan: nanProcessor,
+  template_literal: templateLiteralProcessor,
+  file: fileProcessor,
+  success: successProcessor,
+  custom: customProcessor,
+  function: functionProcessor,
+  transform: transformProcessor,
+  map: mapProcessor,
+  set: setProcessor,
+  array: arrayProcessor,
+  object: objectProcessor,
+  union: unionProcessor,
+  intersection: intersectionProcessor,
+  tuple: tupleProcessor,
+  record: recordProcessor,
+  nullable: nullableProcessor,
+  nonoptional: nonoptionalProcessor,
+  default: defaultProcessor,
+  prefault: prefaultProcessor,
+  catch: catchProcessor,
+  pipe: pipeProcessor,
+  readonly: readonlyProcessor,
+  promise: promiseProcessor,
+  optional: optionalProcessor,
+  lazy: lazyProcessor
+};
+
+// ==================== TOP-LEVEL toJSONSchema ====================
+
+export function toJSONSchema(input, params) {
+  if ("_idmap" in input) {
+    // Registry case
+    const registry = input;
+    const ctx = initializeContext(_objectSpread(_objectSpread({}, params), {}, {
+      processors: allProcessors
+    }));
+    const defs = {};
+
+    // First pass: process all schemas to build the seen map
+    for (const entry of registry._idmap.entries()) {
+      const [_, schema] = entry;
+      process(schema, ctx);
+    }
+    const schemas = {};
+    const external = {
+      registry,
+      uri: params === null || params === void 0 ? void 0 : params.uri,
+      defs
+    };
+
+    // Update the context with external configuration
+    ctx.external = external;
+
+    // Second pass: emit each schema
+    for (const entry of registry._idmap.entries()) {
+      const [key, schema] = entry;
+      extractDefs(ctx, schema);
+      schemas[key] = finalize(ctx, schema);
+    }
+    if (Object.keys(defs).length > 0) {
+      const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+      schemas.__shared = {
+        [defsSegment]: defs
+      };
+    }
+    return {
+      schemas
+    };
+  }
+
+  // Single schema case
+  const ctx = initializeContext(_objectSpread(_objectSpread({}, params), {}, {
+    processors: allProcessors
+  }));
+  process(input, ctx);
+  extractDefs(ctx, input);
+  return finalize(ctx, input);
+}

package/lib/myLib/zod/src/v4/core/json-schema.d.ts

@@ -0,0 +1,88 @@
+export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
+export type _JSONSchema = boolean | JSONSchema;
+export type JSONSchema = {
+    [k: string]: unknown;
+    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+    $id?: string;
+    $anchor?: string;
+    $ref?: string;
+    $dynamicRef?: string;
+    $dynamicAnchor?: string;
+    $vocabulary?: Record<string, boolean>;
+    $comment?: string;
+    $defs?: Record<string, JSONSchema>;
+    type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+    additionalItems?: _JSONSchema;
+    unevaluatedItems?: _JSONSchema;
+    prefixItems?: _JSONSchema[];
+    items?: _JSONSchema | _JSONSchema[];
+    contains?: _JSONSchema;
+    additionalProperties?: _JSONSchema;
+    unevaluatedProperties?: _JSONSchema;
+    properties?: Record<string, _JSONSchema>;
+    patternProperties?: Record<string, _JSONSchema>;
+    dependentSchemas?: Record<string, _JSONSchema>;
+    propertyNames?: _JSONSchema;
+    if?: _JSONSchema;
+    then?: _JSONSchema;
+    else?: _JSONSchema;
+    allOf?: JSONSchema[];
+    anyOf?: JSONSchema[];
+    oneOf?: JSONSchema[];
+    not?: _JSONSchema;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number | boolean;
+    minimum?: number;
+    exclusiveMinimum?: number | boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxContains?: number;
+    minContains?: number;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    dependentRequired?: Record<string, string[]>;
+    enum?: Array<string | number | boolean | null>;
+    const?: string | number | boolean | null;
+    id?: string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    nullable?: boolean;
+    examples?: unknown[];
+    format?: string;
+    contentMediaType?: string;
+    contentEncoding?: string;
+    contentSchema?: JSONSchema;
+    _prefault?: unknown;
+};
+export type BaseSchema = JSONSchema;
+export interface ObjectSchema extends JSONSchema {
+    type: "object";
+}
+export interface ArraySchema extends JSONSchema {
+    type: "array";
+}
+export interface StringSchema extends JSONSchema {
+    type: "string";
+}
+export interface NumberSchema extends JSONSchema {
+    type: "number";
+}
+export interface IntegerSchema extends JSONSchema {
+    type: "integer";
+}
+export interface BooleanSchema extends JSONSchema {
+    type: "boolean";
+}
+export interface NullSchema extends JSONSchema {
+    type: "null";
+}

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

@@ -0,0 +1 @@
+export {};