@amritk/generate-parsers 0.1.0

package/dist/index.js

@@ -0,0 +1,2412 @@
+// ../helpers/dist/build-dynamic-ref-map.js
+var isSchemaObject = (schema) => {
+  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
+};
+var buildDynamicRefMap = (rootSchema) => {
+  const map = {};
+  if (!isSchemaObject(rootSchema) || !("$defs" in rootSchema)) {
+    return map;
+  }
+  const defs = rootSchema.$defs;
+  for (const [key, value] of Object.entries(defs)) {
+    if (typeof value === "object" && value !== null && "$dynamicAnchor" in value && typeof value["$dynamicAnchor"] === "string") {
+      const anchor = value["$dynamicAnchor"];
+      map[`#${anchor}`] = `#/$defs/${key}`;
+    }
+  }
+  return map;
+};
+
+// ../helpers/dist/extract-refs.js
+var isResolvableRef = (ref) => {
+  if (ref === "#")
+    return false;
+  if (ref.startsWith("#"))
+    return true;
+  if (ref.startsWith("http://") || ref.startsWith("https://"))
+    return true;
+  return false;
+};
+var extractRefs = (schema) => {
+  const refs = new Set;
+  const traverse = (obj) => {
+    if (typeof obj !== "object" || obj === null) {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      for (const item of obj) {
+        traverse(item);
+      }
+      return;
+    }
+    const record = obj;
+    if ("$ref" in record && typeof record["$ref"] === "string" && isResolvableRef(record["$ref"])) {
+      refs.add(record["$ref"]);
+    }
+    for (const key in record) {
+      traverse(record[key]);
+    }
+  };
+  traverse(schema);
+  return refs;
+};
+
+// ../helpers/dist/ref-to-filename.js
+var toKebabCase = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+var uriRefToFilename = (uri) => {
+  const hashIndex = uri.indexOf("#");
+  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
+  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
+  const withoutExt = withoutProtocol.replace(/\.json$/, "");
+  const rawSegments = withoutExt.split("/");
+  const SKIP_KEYS = new Set(["definitions", "$defs"]);
+  const segments = [];
+  for (let i = 0;i < rawSegments.length; i++) {
+    const s = rawSegments[i];
+    if (SKIP_KEYS.has(s))
+      continue;
+    const prevRaw = rawSegments[i - 1];
+    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
+      continue;
+    segments.push(s);
+  }
+  const baseName = segments.map((s) => toKebabCase(s).replace(/\./g, "-")).join("-");
+  if (!fragment)
+    return baseName;
+  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
+  const fragLast = fragSegments[fragSegments.length - 1];
+  if (!fragLast)
+    return baseName;
+  return `${baseName}-${toKebabCase(fragLast)}`;
+};
+var refToFilename = (ref) => {
+  if (ref.startsWith("http://") || ref.startsWith("https://")) {
+    return uriRefToFilename(ref);
+  }
+  const segments = ref.split("/");
+  let filename = segments[segments.length - 1];
+  if (/[A-Z]/.test(filename)) {
+    filename = toKebabCase(filename);
+  }
+  return filename;
+};
+
+// ../helpers/dist/ref-to-name.js
+var toKebabCase2 = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+var uriRefToFilename2 = (uri) => {
+  const hashIndex = uri.indexOf("#");
+  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
+  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
+  const withoutExt = withoutProtocol.replace(/\.json$/, "");
+  const rawSegments = withoutExt.split("/");
+  const SKIP_KEYS = new Set(["definitions", "$defs"]);
+  const segments = [];
+  for (let i = 0;i < rawSegments.length; i++) {
+    const s = rawSegments[i];
+    if (SKIP_KEYS.has(s))
+      continue;
+    const prevRaw = rawSegments[i - 1];
+    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
+      continue;
+    segments.push(s);
+  }
+  const baseName = segments.map((s) => toKebabCase2(s).replace(/\./g, "-")).join("-");
+  if (!fragment)
+    return baseName;
+  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
+  const fragLast = fragSegments[fragSegments.length - 1];
+  if (!fragLast)
+    return baseName;
+  return `${baseName}-${toKebabCase2(fragLast)}`;
+};
+var refToFilename2 = (ref) => {
+  if (ref.startsWith("http://") || ref.startsWith("https://")) {
+    return uriRefToFilename2(ref);
+  }
+  const segments = ref.split("/");
+  let filename = segments[segments.length - 1];
+  if (/[A-Z]/.test(filename)) {
+    filename = toKebabCase2(filename);
+  }
+  return filename;
+};
+var kebabToPascal = (kebab) => {
+  const words = kebab.split("-");
+  let pascalCase = "";
+  for (const word of words) {
+    pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
+  }
+  return pascalCase + "Object";
+};
+var refToName = (ref) => kebabToPascal(refToFilename2(ref));
+
+// ../helpers/dist/resolve-dynamic-refs.js
+var resolveDynamicRefs = (schema, dynamicRefMap) => {
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  if (Object.keys(dynamicRefMap).length === 0) {
+    return schema;
+  }
+  const clone = JSON.parse(JSON.stringify(schema));
+  const walk = (obj) => {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+      return;
+    }
+    const record = obj;
+    if ("$dynamicRef" in record && typeof record["$dynamicRef"] === "string") {
+      const resolved = dynamicRefMap[record["$dynamicRef"]];
+      if (resolved) {
+        record["$ref"] = resolved;
+        delete record["$dynamicRef"];
+      }
+    }
+    for (const key in record) {
+      walk(record[key]);
+    }
+  };
+  walk(clone);
+  return clone;
+};
+
+// ../helpers/dist/resolve-ref.js
+var navigatePointer = (pointer, schema) => {
+  const parts = pointer.split("/").filter(Boolean);
+  let current = schema;
+  for (const part of parts) {
+    const decodedPart = part.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (current && typeof current === "object" && decodedPart in current) {
+      const next = current[decodedPart];
+      if (typeof next === "object" && next !== null) {
+        current = next;
+      } else {
+        return;
+      }
+    } else {
+      return;
+    }
+  }
+  return current;
+};
+var resolveRef = (ref, rootSchema) => {
+  if (ref.startsWith("#")) {
+    return navigatePointer(ref.slice(1), rootSchema);
+  }
+  const hashIndex = ref.indexOf("#");
+  const baseUri = hashIndex === -1 ? ref : ref.slice(0, hashIndex);
+  const rawFragment = hashIndex === -1 ? "" : ref.slice(hashIndex + 1);
+  const fragment = rawFragment === "" || rawFragment === "/" ? "" : rawFragment;
+  const defs = rootSchema["$defs"];
+  if (typeof defs !== "object" || defs === null)
+    return;
+  const defsRecord = defs;
+  const base = defsRecord[baseUri];
+  if (typeof base !== "object" || base === null)
+    return;
+  if (!fragment)
+    return base;
+  const normalizedFragment = fragment.replace(/^\/definitions\//, "/$defs/");
+  return navigatePointer(normalizedFragment, base);
+};
+
+// ../helpers/dist/upgrade-draft07-schema.js
+var toKebabCase3 = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+var uriRefToFilename3 = (uri) => {
+  const hashIndex = uri.indexOf("#");
+  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
+  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
+  const withoutExt = withoutProtocol.replace(/\.json$/, "");
+  const rawSegments = withoutExt.split("/");
+  const SKIP_KEYS = new Set(["definitions", "$defs"]);
+  const segments = [];
+  for (let i = 0;i < rawSegments.length; i++) {
+    const s = rawSegments[i];
+    if (SKIP_KEYS.has(s))
+      continue;
+    const prevRaw = rawSegments[i - 1];
+    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
+      continue;
+    segments.push(s);
+  }
+  const baseName = segments.map((s) => toKebabCase3(s).replace(/\./g, "-")).join("-");
+  if (!fragment)
+    return baseName;
+  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
+  const fragLast = fragSegments[fragSegments.length - 1];
+  if (!fragLast)
+    return baseName;
+  return `${baseName}-${toKebabCase3(fragLast)}`;
+};
+var refToFilename3 = (ref) => {
+  if (ref.startsWith("http://") || ref.startsWith("https://")) {
+    return uriRefToFilename3(ref);
+  }
+  const segments = ref.split("/");
+  let filename = segments[segments.length - 1];
+  if (/[A-Z]/.test(filename)) {
+    filename = toKebabCase3(filename);
+  }
+  return filename;
+};
+var isDraft07Schema = (schema) => typeof schema["$schema"] === "string" && schema["$schema"].includes("draft-07");
+var rewriteRefs = (obj, refMap, selfRef) => {
+  if (typeof obj !== "object" || obj === null)
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map((item) => rewriteRefs(item, refMap, selfRef));
+  const record = obj;
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "$ref" && typeof value === "string") {
+      if (refMap.has(value)) {
+        result[key] = refMap.get(value);
+      } else if (value === "#" && selfRef) {
+        result[key] = selfRef;
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = rewriteRefs(value, refMap, selfRef);
+    }
+  }
+  return result;
+};
+var hoistNestedDefs = (defs) => {
+  const hoisted = {};
+  for (const [parentName, parentSchema] of Object.entries(defs)) {
+    if (typeof parentSchema !== "object" || parentSchema === null) {
+      hoisted[parentName] = parentSchema;
+      continue;
+    }
+    const parentObj = parentSchema;
+    const nestedDefs = parentObj["$defs"];
+    if (!nestedDefs || typeof nestedDefs !== "object") {
+      hoisted[parentName] = parentSchema;
+      continue;
+    }
+    const parentPrefix = parentName.startsWith("http://") || parentName.startsWith("https://") ? refToFilename3(parentName) : parentName;
+    const localToHoisted = new Map;
+    for (const localName of Object.keys(nestedDefs)) {
+      const hoistedName = `${parentPrefix}-${toKebabCase3(localName)}`;
+      localToHoisted.set(`#/$defs/${localName}`, `#/$defs/${hoistedName}`);
+    }
+    const selfRef = `#/$defs/${parentPrefix}`;
+    const rewrittenParent = rewriteRefs(parentObj, localToHoisted, selfRef);
+    hoisted[parentName] = rewrittenParent;
+    for (const [localName, localSchema] of Object.entries(nestedDefs)) {
+      const hoistedName = `${parentPrefix}-${toKebabCase3(localName)}`;
+      hoisted[hoistedName] = rewriteRefs(localSchema, localToHoisted, selfRef);
+    }
+  }
+  return hoisted;
+};
+var upgradeDraft07Schema = (schema) => {
+  if (!isDraft07Schema(schema))
+    return schema;
+  const { definitions, $schema: _, ...rest } = schema;
+  const rawDefs = definitions ?? {};
+  const renamedDefs = {};
+  for (const [key, value] of Object.entries(rawDefs)) {
+    renamedDefs[key] = renameNestedDefs(value);
+  }
+  const hoistedDefs = hoistNestedDefs(renamedDefs);
+  for (const key of Object.keys(hoistedDefs)) {
+    if (key.startsWith("http://") || key.startsWith("https://")) {
+      const shortName = refToFilename3(key);
+      if (shortName && !(shortName in hoistedDefs)) {
+        hoistedDefs[shortName] = hoistedDefs[key];
+      }
+    }
+  }
+  return {
+    ...rest,
+    $defs: hoistedDefs
+  };
+};
+var renameNestedDefs = (obj) => {
+  if (typeof obj !== "object" || obj === null)
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(renameNestedDefs);
+  const record = obj;
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "$ref" && typeof value === "string" && value.startsWith("#/definitions/")) {
+      result[key] = value.replace("#/definitions/", "#/$defs/");
+    } else {
+      const outKey = key === "definitions" ? "$defs" : key;
+      result[outKey] = renameNestedDefs(value);
+    }
+  }
+  return result;
+};
+
+// src/helpers/apply-schema-extensions.ts
+var applySchemaExtensions = (schema, definitionName, extensions) => {
+  const extensionProperties = extensions[definitionName];
+  if (!extensionProperties || Object.keys(extensionProperties).length === 0) {
+    return schema;
+  }
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  const existingProperties = "properties" in schema && typeof schema.properties === "object" && schema.properties !== null ? schema.properties : {};
+  return {
+    ...schema,
+    properties: {
+      ...existingProperties,
+      ...extensionProperties
+    }
+  };
+};
+
+// ../helpers/dist/generate-type-definition.js
+var isSchemaObject2 = (schema) => {
+  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
+};
+var isObjectSchema = (schema) => {
+  return isSchemaObject2(schema) && (("type" in schema) && schema.type === "object" || ("properties" in schema));
+};
+var toKebabCase4 = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+var uriRefToFilename4 = (uri) => {
+  const hashIndex = uri.indexOf("#");
+  const baseUri = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+  const fragment = hashIndex === -1 ? "" : uri.slice(hashIndex + 1);
+  const withoutProtocol = baseUri.replace(/^https?:\/\/[^/]+\//, "");
+  const withoutExt = withoutProtocol.replace(/\.json$/, "");
+  const rawSegments = withoutExt.split("/");
+  const SKIP_KEYS = new Set(["definitions", "$defs"]);
+  const segments = [];
+  for (let i = 0;i < rawSegments.length; i++) {
+    const s = rawSegments[i];
+    if (SKIP_KEYS.has(s))
+      continue;
+    const prevRaw = rawSegments[i - 1];
+    if (/^\d+\.\d+/.test(s) && prevRaw !== undefined && SKIP_KEYS.has(prevRaw))
+      continue;
+    segments.push(s);
+  }
+  const baseName = segments.map((s) => toKebabCase4(s).replace(/\./g, "-")).join("-");
+  if (!fragment)
+    return baseName;
+  const fragSegments = fragment.split("/").filter((s) => s && !SKIP_KEYS.has(s) && s !== "properties");
+  const fragLast = fragSegments[fragSegments.length - 1];
+  if (!fragLast)
+    return baseName;
+  return `${baseName}-${toKebabCase4(fragLast)}`;
+};
+var refToFilename4 = (ref) => {
+  if (ref.startsWith("http://") || ref.startsWith("https://")) {
+    return uriRefToFilename4(ref);
+  }
+  const segments = ref.split("/");
+  let filename = segments[segments.length - 1];
+  if (/[A-Z]/.test(filename)) {
+    filename = toKebabCase4(filename);
+  }
+  return filename;
+};
+var kebabToPascal2 = (kebab) => {
+  const words = kebab.split("-");
+  let pascalCase = "";
+  for (const word of words) {
+    pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
+  }
+  return pascalCase + "Object";
+};
+var refToName2 = (ref) => kebabToPascal2(refToFilename4(ref));
+var JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var safeKey = (key) => {
+  if (JS_IDENTIFIER.test(key)) {
+    return key;
+  }
+  return `'${key}'`;
+};
+var getConditionalObjectSchema = (schema) => {
+  if (!isSchemaObject2(schema)) {
+    return null;
+  }
+  if (!("if" in schema) || !("then" in schema)) {
+    return null;
+  }
+  const ifSchema = schema.if;
+  const thenSchema = schema.then;
+  if (!isSchemaObject2(ifSchema) || !isSchemaObject2(thenSchema)) {
+    return null;
+  }
+  const ifProperties = ifSchema.properties;
+  const thenProperties = thenSchema.properties;
+  const hasIfProperties = ifProperties && typeof ifProperties === "object";
+  const hasThenProperties = thenProperties && typeof thenProperties === "object";
+  if (!hasIfProperties && !hasThenProperties) {
+    return null;
+  }
+  const properties = {
+    ...hasIfProperties ? ifProperties : {},
+    ...hasThenProperties ? thenProperties : {}
+  };
+  const required = new Set;
+  if (Array.isArray(ifSchema.required)) {
+    for (const key of ifSchema.required) {
+      required.add(key);
+    }
+  }
+  if (hasIfProperties) {
+    for (const key in ifProperties) {
+      required.add(key);
+    }
+  }
+  if (Array.isArray(thenSchema.required)) {
+    for (const key of thenSchema.required) {
+      required.add(key);
+    }
+  }
+  if (hasThenProperties) {
+    for (const key in thenProperties) {
+      required.add(key);
+    }
+  }
+  const thenRef = typeof thenSchema.$ref === "string" ? thenSchema.$ref : null;
+  return {
+    schema: {
+      type: "object",
+      properties,
+      ...required.size > 0 ? { required: Array.from(required) } : {}
+    },
+    thenRef
+  };
+};
+var isObjectLikeSchema = (schema) => {
+  if (!isSchemaObject2(schema)) {
+    return false;
+  }
+  if (isObjectSchema(schema)) {
+    return true;
+  }
+  return "patternProperties" in schema || "additionalProperties" in schema || "if" in schema && "then" in schema;
+};
+var getBooleanSubSchemaType = (schema) => {
+  return schema ? "unknown" : "never";
+};
+var buildJsDocBlock = (title, description, commentUrl) => {
+  let block = `/**
+`;
+  block += `* ${title}
+`;
+  block += `*
+`;
+  block += `* ${description}
+`;
+  if (commentUrl?.startsWith("http")) {
+    block += `* 
+`;
+    block += `* @see {@link ${commentUrl}}
+`;
+  }
+  block += `*/
+`;
+  return block;
+};
+var getTypeScriptType = (schema) => {
+  if (typeof schema === "boolean") {
+    return getBooleanSubSchemaType(schema);
+  }
+  if (typeof schema !== "object" || schema === null) {
+    return "unknown";
+  }
+  if (schema.$ref) {
+    if (!schema.$ref.startsWith("#")) {
+      return "unknown";
+    }
+    return refToName2(schema.$ref);
+  }
+  if (schema.$dynamicRef) {
+    if (schema.$dynamicRef === "#meta") {
+      return "Schema";
+    }
+    return refToName2(schema.$dynamicRef);
+  }
+  if (schema.const !== undefined) {
+    return JSON.stringify(schema.const);
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    if (schema.enum.length === 1) {
+      return JSON.stringify(schema.enum[0]);
+    }
+    let enumUnion = JSON.stringify(schema.enum[0]);
+    for (let i = 1;i < schema.enum.length; i++) {
+      enumUnion += " | " + JSON.stringify(schema.enum[i]);
+    }
+    return enumUnion;
+  }
+  if (schema.enum && schema.enum.length > 1) {
+    let multiEnumUnion = JSON.stringify(schema.enum[0]);
+    for (let i = 1;i < schema.enum.length; i++) {
+      multiEnumUnion += " | " + JSON.stringify(schema.enum[i]);
+    }
+    return multiEnumUnion;
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+    let oneOfUnion = getTypeScriptType(schema.oneOf[0]);
+    for (let i = 1;i < schema.oneOf.length; i++) {
+      oneOfUnion += " | " + getTypeScriptType(schema.oneOf[i]);
+    }
+    return oneOfUnion;
+  }
+  if (schema.anyOf && Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+    let anyOfUnion = getTypeScriptType(schema.anyOf[0]);
+    for (let i = 1;i < schema.anyOf.length; i++) {
+      anyOfUnion += " | " + getTypeScriptType(schema.anyOf[i]);
+    }
+    return anyOfUnion;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+    let intersectionTypes = getTypeScriptType(schema.allOf[0]);
+    for (let i = 1;i < schema.allOf.length; i++) {
+      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i]);
+    }
+    return intersectionTypes;
+  }
+  const conditionalResult = getConditionalObjectSchema(schema);
+  if (conditionalResult) {
+    const baseType = getTypeScriptType(conditionalResult.schema);
+    if (conditionalResult.thenRef) {
+      return `(${baseType}) & ${refToName2(conditionalResult.thenRef)}`;
+    }
+    return baseType;
+  }
+  if (!schema.type) {
+    if (schema.additionalProperties !== undefined) {
+      if (typeof schema.additionalProperties === "boolean") {
+        return `Record<string, ${getBooleanSubSchemaType(schema.additionalProperties)}>`;
+      }
+      return `Record<string, ${getTypeScriptType(schema.additionalProperties)}>`;
+    }
+    if (schema.patternProperties && typeof schema.patternProperties === "object") {
+      const firstEntry = Object.entries(schema.patternProperties)[0];
+      if (firstEntry) {
+        const [pattern, value] = firstEntry;
+        if (value !== undefined) {
+          const valueType = typeof value === "boolean" ? getBooleanSubSchemaType(value) : getTypeScriptType(value);
+          if (pattern === "^x-") {
+            return `Record<\`x-\${string}\`, ${valueType}>`;
+          }
+          return `Record<string, ${valueType}>`;
+        }
+      }
+    }
+    if (schema.default !== undefined) {
+      if (typeof schema.default === "string") {
+        return "string";
+      }
+      if (typeof schema.default === "number") {
+        return "number";
+      }
+      if (typeof schema.default === "boolean") {
+        return "boolean";
+      }
+    }
+    return "unknown";
+  }
+  if (Array.isArray(schema.type)) {
+    const mapType = (t) => {
+      switch (t) {
+        case "string":
+          return "string";
+        case "number":
+        case "integer":
+          return "number";
+        case "boolean":
+          return "boolean";
+        case "null":
+          return "null";
+        case "array":
+          return "unknown[]";
+        case "object":
+          return "Record<string, unknown>";
+        default:
+          return "unknown";
+      }
+    };
+    let typeUnion = mapType(schema.type[0]);
+    for (let i = 1;i < schema.type.length; i++) {
+      typeUnion += " | " + mapType(schema.type[i]);
+    }
+    return typeUnion;
+  }
+  switch (schema.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      if (schema.items) {
+        const itemType = getTypeScriptType(schema.items);
+        const wrappedItemType = itemType.includes(" | ") ? `(${itemType})` : itemType;
+        return `${wrappedItemType}[]`;
+      }
+      return "unknown[]";
+    case "object":
+      if (schema.properties) {
+        let properties = "";
+        let first = true;
+        for (const key in schema.properties) {
+          const propSchema = schema.properties[key];
+          const isRequired = schema.required?.includes(key) ?? false;
+          const optional = isRequired ? "" : "?";
+          const propType = getTypeScriptType(propSchema);
+          if (!first)
+            properties += "; ";
+          properties += safeKey(key) + optional + ": " + propType;
+          first = false;
+        }
+        return "{ " + properties + " }";
+      }
+      if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+        const additionalPropType = getTypeScriptType(schema.additionalProperties);
+        return `Record<string, ${additionalPropType}>`;
+      }
+      if (schema.patternProperties && typeof schema.patternProperties === "object") {
+        const firstEntry = Object.entries(schema.patternProperties)[0];
+        if (firstEntry) {
+          const [pattern, patternVal] = firstEntry;
+          if (patternVal) {
+            const valueType = getTypeScriptType(patternVal);
+            if (pattern === "^x-") {
+              return `Record<\`x-\${string}\`, ${valueType}>`;
+            }
+            return `Record<string, ${valueType}>`;
+          }
+        }
+      }
+      return "object";
+    default:
+      return "unknown";
+  }
+};
+var generateTypeDefinition = (schema, typeName) => {
+  if (!isObjectLikeSchema(schema)) {
+    const tsType = getTypeScriptType(schema);
+    let result = "";
+    if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
+      result += buildJsDocBlock(typeName, schema.$comment);
+    }
+    result += `export type ${typeName} = ${tsType};`;
+    return result;
+  }
+  if (isObjectLikeSchema(schema)) {
+    const conditionalResult = getConditionalObjectSchema(schema);
+    const normalizedSchema = conditionalResult?.schema ?? schema;
+    const conditionalThenRef = conditionalResult?.thenRef ?? null;
+    let jsDocTitle;
+    let jsDocDescription;
+    if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
+      jsDocTitle = typeName;
+      jsDocDescription = schema.$comment;
+    }
+    const hasProperties2 = normalizedSchema.properties && Object.keys(normalizedSchema.properties).length > 0;
+    const hasAdditionalProperties2 = normalizedSchema.additionalProperties && typeof normalizedSchema.additionalProperties === "object";
+    const hasPatternProperties = normalizedSchema.patternProperties && typeof normalizedSchema.patternProperties === "object" && Object.keys(normalizedSchema.patternProperties).length > 0;
+    if (!hasProperties2 && hasPatternProperties && normalizedSchema.patternProperties) {
+      const firstEntry = Object.entries(normalizedSchema.patternProperties)[0];
+      const firstPattern = firstEntry?.[0];
+      const firstPatternProperty = firstEntry?.[1];
+      if (firstPatternProperty === undefined) {
+        return `export type ${typeName} = Record<string, unknown>;`;
+      }
+      const patternPropType = typeof firstPatternProperty === "boolean" ? getBooleanSubSchemaType(firstPatternProperty) : getTypeScriptType(firstPatternProperty);
+      const keyType = firstPattern === "^x-" ? "`x-${string}`" : "string";
+      let result2 = "";
+      if (jsDocTitle && jsDocDescription) {
+        result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
+      }
+      result2 += `export type ${typeName} = Record<${keyType}, ${patternPropType}>;`;
+      return result2;
+    }
+    if (!hasProperties2 && hasAdditionalProperties2 && normalizedSchema.additionalProperties) {
+      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties);
+      let result2 = "";
+      if (jsDocTitle && jsDocDescription) {
+        result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
+      }
+      result2 += `export type ${typeName} = {
+  [key: string]: ${additionalPropType};
+};`;
+      return result2;
+    }
+    const schemaProps = normalizedSchema.properties ?? {};
+    let properties = "";
+    let isFirstProp = true;
+    for (const key in schemaProps) {
+      const propSchema = schemaProps[key];
+      const isRequired = normalizedSchema.required?.includes(key) ?? false;
+      const optional = isRequired ? "" : "?";
+      const propType = getTypeScriptType(propSchema);
+      const quotedKey = safeKey(key);
+      if (!isFirstProp)
+        properties += `
+`;
+      isFirstProp = false;
+      const inlineDescription = isSchemaObject2(propSchema) && typeof propSchema.description === "string" ? propSchema.description : isSchemaObject2(propSchema) && typeof propSchema.$comment === "string" ? propSchema.$comment : undefined;
+      if (inlineDescription) {
+        properties += "  /** " + inlineDescription + ` */
+  ` + quotedKey + optional + ": " + propType + ";";
+      } else {
+        properties += "  " + quotedKey + optional + ": " + propType + ";";
+      }
+    }
+    const allOfIntersections = [];
+    if (isSchemaObject2(schema) && Array.isArray(schema.allOf)) {
+      for (const entry of schema.allOf) {
+        if (isSchemaObject2(entry) && entry.$ref) {
+          allOfIntersections.push(refToName2(entry.$ref));
+        }
+      }
+    }
+    if (isSchemaObject2(schema) && typeof schema.$ref === "string" && schema.$ref.startsWith("#")) {
+      allOfIntersections.push(refToName2(schema.$ref));
+    }
+    let result = "";
+    if (jsDocTitle && jsDocDescription) {
+      result += buildJsDocBlock(jsDocTitle, jsDocDescription);
+    }
+    let typeBody = `{
+` + properties + `
+}`;
+    if (conditionalThenRef) {
+      typeBody += " & " + refToName2(conditionalThenRef);
+    }
+    for (const intersectionType of allOfIntersections) {
+      typeBody += " & " + intersectionType;
+    }
+    result += "export type " + typeName + " = " + typeBody + ";";
+    return result;
+  }
+  return "export type " + typeName + " = unknown;";
+};
+
+// src/helpers/collect-helpers.ts
+var collectHelpers = (parserFunction) => {
+  const imports = [];
+  if (parserFunction.includes("validateArray")) {
+    imports.push("import { validateArray } from '@amritk/helpers/validate-array';");
+  }
+  if (parserFunction.includes("validateRecord")) {
+    imports.push("import { validateRecord } from '@amritk/helpers/validate-record';");
+  }
+  if (parserFunction.includes("isObject")) {
+    imports.push("import { isObject } from '@amritk/helpers/is-object';");
+  }
+  if (parserFunction.includes("hasRef(")) {
+    imports.push("import { hasRef } from '@amritk/helpers/schema-guards';");
+  }
+  return imports;
+};
+
+// ../helpers/dist/schema-guards.js
+var isSchemaObject3 = (schema) => {
+  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
+};
+var hasType = (schema) => {
+  return isSchemaObject3(schema) && "type" in schema && typeof schema.type === "string";
+};
+var isObjectSchema2 = (schema) => {
+  return isSchemaObject3(schema) && (("type" in schema) && schema.type === "object" || ("properties" in schema));
+};
+var hasProperties = (schema) => {
+  return isSchemaObject3(schema) && "properties" in schema && typeof schema.properties === "object" && schema.properties !== null;
+};
+var hasEnum = (schema) => {
+  return isSchemaObject3(schema) && "enum" in schema && Array.isArray(schema.enum);
+};
+var hasConst = (schema) => {
+  return isSchemaObject3(schema) && "const" in schema;
+};
+var hasPattern = (schema) => {
+  return isSchemaObject3(schema) && "pattern" in schema && typeof schema.pattern === "string";
+};
+var hasDefault = (schema) => {
+  return isSchemaObject3(schema) && "default" in schema;
+};
+var hasExamples = (schema) => {
+  return isSchemaObject3(schema) && "examples" in schema && Array.isArray(schema.examples);
+};
+var hasOneOf = (schema) => {
+  return isSchemaObject3(schema) && "oneOf" in schema && Array.isArray(schema.oneOf);
+};
+var hasAnyOf = (schema) => {
+  return isSchemaObject3(schema) && "anyOf" in schema && Array.isArray(schema.anyOf);
+};
+var hasAllOf = (schema) => {
+  return isSchemaObject3(schema) && "allOf" in schema && Array.isArray(schema.allOf);
+};
+var hasRequired = (schema) => {
+  return isSchemaObject3(schema) && "required" in schema && Array.isArray(schema.required);
+};
+var hasItems = (schema) => {
+  return isSchemaObject3(schema) && "items" in schema && typeof schema.items === "object" && schema.items !== null && typeof schema.items !== "boolean";
+};
+var hasAdditionalProperties = (schema) => {
+  return isSchemaObject3(schema) && "additionalProperties" in schema;
+};
+var hasMinLength = (schema) => {
+  return isSchemaObject3(schema) && "minLength" in schema && typeof schema.minLength === "number";
+};
+var hasMaxLength = (schema) => {
+  return isSchemaObject3(schema) && "maxLength" in schema && typeof schema.maxLength === "number";
+};
+var hasMinimum = (schema) => {
+  return isSchemaObject3(schema) && "minimum" in schema && typeof schema.minimum === "number";
+};
+var hasMaximum = (schema) => {
+  return isSchemaObject3(schema) && "maximum" in schema && typeof schema.maximum === "number";
+};
+var hasExclusiveMinimum = (schema) => {
+  return isSchemaObject3(schema) && "exclusiveMinimum" in schema && typeof schema.exclusiveMinimum === "number";
+};
+var hasExclusiveMaximum = (schema) => {
+  return isSchemaObject3(schema) && "exclusiveMaximum" in schema && typeof schema.exclusiveMaximum === "number";
+};
+var hasMultipleOf = (schema) => {
+  return isSchemaObject3(schema) && "multipleOf" in schema && typeof schema.multipleOf === "number";
+};
+var hasMinItems = (schema) => {
+  return isSchemaObject3(schema) && "minItems" in schema && typeof schema.minItems === "number";
+};
+var hasMaxItems = (schema) => {
+  return isSchemaObject3(schema) && "maxItems" in schema && typeof schema.maxItems === "number";
+};
+var hasUniqueItems = (schema) => {
+  return isSchemaObject3(schema) && "uniqueItems" in schema && typeof schema.uniqueItems === "boolean";
+};
+var hasMinProperties = (schema) => {
+  return isSchemaObject3(schema) && "minProperties" in schema && typeof schema.minProperties === "number";
+};
+var hasMaxProperties = (schema) => {
+  return isSchemaObject3(schema) && "maxProperties" in schema && typeof schema.maxProperties === "number";
+};
+var hasRef = (schema) => {
+  return isSchemaObject3(schema) && "$ref" in schema && typeof schema.$ref === "string";
+};
+
+// src/helpers/collect-imports.ts
+var getImportPathForFilename = (filename) => `./${filename}`;
+var collectImports = (schema, options) => {
+  const typesOnly = options?.typesOnly === true;
+  const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : undefined;
+  const rootSchema = options?.rootSchema;
+  const refs = new Set;
+  const collectRefsFromValue = (value) => {
+    if (typeof value !== "object" || value === null) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        collectRefsFromValue(item);
+      }
+      return;
+    }
+    const record = value;
+    if (hasRef(record)) {
+      const ref = record.$ref;
+      const isInternal = ref.startsWith("#");
+      const isUri = ref.startsWith("http://") || ref.startsWith("https://");
+      const isPropertyFragment = isUri && ref.includes("#/properties/");
+      if (isInternal || isUri && !isPropertyFragment) {
+        refs.add(ref);
+      }
+      return;
+    }
+    if (hasAdditionalProperties(record) && hasRef(record.additionalProperties)) {
+      collectRefsFromValue(record.additionalProperties);
+      return;
+    }
+    if (record.type === "array" && hasItems(record) && hasRef(record.items)) {
+      collectRefsFromValue(record.items);
+      return;
+    }
+    if ("properties" in record && typeof record.properties === "object" && record.properties !== null) {
+      const props = record.properties;
+      for (const key in props) {
+        collectRefsFromValue(props[key]);
+      }
+    }
+    if (hasOneOf(record)) {
+      for (const item of record.oneOf) {
+        collectRefsFromValue(item);
+      }
+    }
+    if (hasAnyOf(record)) {
+      for (const item of record.anyOf) {
+        collectRefsFromValue(item);
+      }
+    }
+    if (hasAllOf(record)) {
+      for (const item of record.allOf) {
+        collectRefsFromValue(item);
+      }
+    }
+    if (hasItems(record)) {
+      collectRefsFromValue(record.items);
+    }
+    if (hasAdditionalProperties(record)) {
+      collectRefsFromValue(record.additionalProperties);
+    }
+    if ("patternProperties" in record && typeof record.patternProperties === "object" && record.patternProperties !== null) {
+      const patternProps = record.patternProperties;
+      for (const key in patternProps) {
+        collectRefsFromValue(patternProps[key]);
+      }
+    }
+    if ("then" in record) {
+      collectRefsFromValue(record.then);
+    }
+    if ("else" in record) {
+      collectRefsFromValue(record.else);
+    }
+  };
+  if (typeof schema === "object" && schema !== null && hasRef(schema)) {
+    const ref = schema.$ref;
+    const isInternal = ref.startsWith("#");
+    const isUri = ref.startsWith("http://") || ref.startsWith("https://");
+    const isPropertyFragment = isUri && ref.includes("#/properties/");
+    if (isInternal || isUri && !isPropertyFragment) {
+      refs.add(ref);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "properties" in schema) {
+    const properties = schema.properties;
+    for (const key in properties) {
+      collectRefsFromValue(properties[key]);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "additionalProperties" in schema) {
+    collectRefsFromValue(schema.additionalProperties);
+  }
+  if (typeof schema === "object" && schema !== null && "patternProperties" in schema) {
+    const patternProps = schema.patternProperties;
+    for (const key in patternProps) {
+      collectRefsFromValue(patternProps[key]);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && hasItems(schema)) {
+    collectRefsFromValue(schema.items);
+  }
+  if (typeof schema === "object" && schema !== null && hasOneOf(schema)) {
+    for (const item of schema.oneOf) {
+      collectRefsFromValue(item);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && hasAnyOf(schema)) {
+    for (const item of schema.anyOf) {
+      collectRefsFromValue(item);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && hasAllOf(schema)) {
+    for (const item of schema.allOf) {
+      collectRefsFromValue(item);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "if" in schema) {
+    collectRefsFromValue(schema.if);
+  }
+  if (typeof schema === "object" && schema !== null && "then" in schema) {
+    collectRefsFromValue(schema.then);
+  }
+  if (typeof schema === "object" && schema !== null && "else" in schema) {
+    collectRefsFromValue(schema.else);
+  }
+  const importMap = new Map;
+  for (const ref of refs) {
+    if (rootSchema !== undefined && (ref.startsWith("http://") || ref.startsWith("https://"))) {
+      if (!resolveRef(ref, rootSchema))
+        continue;
+    }
+    const typeName = refToName(ref);
+    const filename = refToFilename(ref);
+    if (selfFilename !== undefined && filename === selfFilename) {
+      continue;
+    }
+    const importPath = getImportPathForFilename(filename);
+    const importStatement = typesOnly ? `import type { ${typeName} } from '${importPath}';` : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
+    importMap.set(filename, importStatement);
+  }
+  return Array.from(importMap.values()).sort();
+};
+
+// ../helpers/dist/safe-accessor.js
+var JS_IDENTIFIER2 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var safeAccessor = (variable, key) => {
+  if (JS_IDENTIFIER2.test(key)) {
+    return `${variable}.${key}`;
+  }
+  if (variable.endsWith("?")) {
+    return `${variable}.['${key}']`;
+  }
+  return `${variable}['${key}']`;
+};
+var safeKey2 = (key) => {
+  if (JS_IDENTIFIER2.test(key)) {
+    return key;
+  }
+  return `'${key}'`;
+};
+
+// src/generators/generate-default-from-pattern.ts
+var generateDefaultFromPattern = (pattern) => {
+  if (pattern.includes("@") || pattern.includes("[a-zA-Z0-9]") && pattern.includes("\\.")) {
+    return '"user@example.com"';
+  }
+  if (pattern.includes("[0-9a-f]") && pattern.includes("{8}") || pattern.includes("\\-")) {
+    if (pattern.match(/[0-9a-f].*\{8\}/i) || pattern.match(/[0-9a-fA-F]{8}/)) {
+      return '"00000000-0000-0000-0000-000000000000"';
+    }
+  }
+  if (pattern.includes("https?") || pattern.includes("http")) {
+    return '"https://example.com"';
+  }
+  if (pattern.match(/\d.*\\\.\.*\d/)) {
+    return '"1.0.0"';
+  }
+  if (pattern.includes("\\d{4}") && pattern.includes("\\d{2}")) {
+    return '"2000-01-01"';
+  }
+  if (pattern.includes("\\d{3}") && (pattern.includes("\\d{4}") || pattern.includes("\\d{7}"))) {
+    return '"+1234567890"';
+  }
+  return null;
+};
+
+// src/helpers/get-default-value.ts
+var getDefaultValue = (schema) => {
+  if (!isSchemaObject3(schema)) {
+    return "undefined";
+  }
+  if (hasDefault(schema)) {
+    return JSON.stringify(schema.default);
+  }
+  if (hasEnum(schema) && schema.enum.length > 0) {
+    return JSON.stringify(schema.enum[0]);
+  }
+  if (hasExamples(schema) && schema.examples.length > 0) {
+    return JSON.stringify(schema.examples[0]);
+  }
+  if (hasOneOf(schema) && schema.oneOf.length > 0) {
+    const firstSchema = schema.oneOf[0];
+    if (firstSchema !== undefined) {
+      return getDefaultValue(firstSchema);
+    }
+  }
+  if (hasAnyOf(schema) && schema.anyOf.length > 0) {
+    const firstSchema = schema.anyOf[0];
+    if (firstSchema !== undefined) {
+      return getDefaultValue(firstSchema);
+    }
+  }
+  if (hasAllOf(schema) && schema.allOf.length > 0) {
+    const firstSchema = schema.allOf[0];
+    if (firstSchema !== undefined) {
+      return getDefaultValue(firstSchema);
+    }
+  }
+  if (!hasType(schema)) {
+    return "undefined";
+  }
+  switch (schema.type) {
+    case "string": {
+      if (hasPattern(schema)) {
+        const patternDefault = generateDefaultFromPattern(schema.pattern);
+        if (patternDefault) {
+          return patternDefault;
+        }
+      }
+      return '""';
+    }
+    case "number":
+    case "integer":
+      return "0";
+    case "boolean":
+      return "false";
+    case "array":
+      return "[]";
+    case "object":
+      return "{}";
+    default:
+      return "undefined";
+  }
+};
+
+// src/helpers/find-discriminator.ts
+var findDiscriminator = (schemas) => {
+  const propertyValues = new Map;
+  for (const schema of schemas) {
+    if (isObjectSchema2(schema) && hasProperties(schema)) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (!propertyValues.has(key)) {
+          propertyValues.set(key, new Set);
+        }
+        if (isSchemaObject3(propSchema) && hasConst(propSchema)) {
+          propertyValues.get(key)?.add(propSchema.const);
+        } else if (isSchemaObject3(propSchema) && hasEnum(propSchema) && propSchema.enum.length === 1) {
+          propertyValues.get(key)?.add(propSchema.enum[0]);
+        }
+      }
+    }
+  }
+  for (const [key, values] of propertyValues.entries()) {
+    if (values.size === schemas.length) {
+      return key;
+    }
+  }
+  return null;
+};
+
+// src/helpers/get-discriminator-value.ts
+var getDiscriminatorValue = (schema, discriminatorKey) => {
+  if (isObjectSchema2(schema) && hasProperties(schema)) {
+    const propSchema = schema.properties[discriminatorKey];
+    if (propSchema && isSchemaObject3(propSchema)) {
+      if (hasConst(propSchema)) {
+        return propSchema.const;
+      }
+      if (hasEnum(propSchema) && propSchema.enum.length === 1) {
+        return propSchema.enum[0];
+      }
+    }
+  }
+  return null;
+};
+
+// src/generators/generate-enum-check.ts
+var generateEnumCheck = (accessor, enumValues) => {
+  const serializedEnum = JSON.stringify(enumValues);
+  return `${serializedEnum}.includes(${accessor} as never)`;
+};
+
+// src/generators/generate-schema-checks.ts
+var generateSchemaChecks = (accessor, schema) => {
+  const checks = [];
+  if (!hasType(schema)) {
+    return checks;
+  }
+  switch (schema.type) {
+    case "string": {
+      checks.push(`typeof ${accessor} === "string"`);
+      if (hasPattern(schema)) {
+        checks.push(`/${schema.pattern.replace(/\//g, "\\/")}/.test(${accessor})`);
+      }
+      if (hasMinLength(schema)) {
+        checks.push(`${accessor}.length >= ${schema.minLength}`);
+      }
+      if (hasMaxLength(schema)) {
+        checks.push(`${accessor}.length <= ${schema.maxLength}`);
+      }
+      break;
+    }
+    case "number":
+    case "integer":
+      checks.push(`typeof ${accessor} === "number"`);
+      if (hasMinimum(schema)) {
+        checks.push(`${accessor} >= ${schema.minimum}`);
+      }
+      if (hasMaximum(schema)) {
+        checks.push(`${accessor} <= ${schema.maximum}`);
+      }
+      if (hasExclusiveMinimum(schema)) {
+        checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
+      }
+      if (hasExclusiveMaximum(schema)) {
+        checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
+      }
+      if (hasMultipleOf(schema)) {
+        checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+      }
+      break;
+    case "boolean":
+      checks.push(`typeof ${accessor} === "boolean"`);
+      break;
+    case "array":
+      checks.push(`Array.isArray(${accessor})`);
+      if (hasMinItems(schema)) {
+        checks.push(`${accessor}.length >= ${schema.minItems}`);
+      }
+      if (hasMaxItems(schema)) {
+        checks.push(`${accessor}.length <= ${schema.maxItems}`);
+      }
+      if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+        checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+      }
+      break;
+    case "object": {
+      checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`);
+      if (hasRequired(schema) && schema.required.length > 0) {
+        for (const requiredKey of schema.required) {
+          checks.push(`"${requiredKey}" in ${accessor}`);
+        }
+      }
+      if (hasMinProperties(schema)) {
+        checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
+      }
+      if (hasMaxProperties(schema)) {
+        checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
+      }
+      if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
+        const allowedKeys = Object.keys(schema.properties);
+        const allowedKeysStr = JSON.stringify(allowedKeys);
+        checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`);
+      }
+      break;
+    }
+  }
+  if (hasEnum(schema) && schema.enum.length > 0) {
+    checks.push(generateEnumCheck(accessor, schema.enum));
+  }
+  return checks;
+};
+
+// src/generators/generate-discriminated-union-validation.ts
+var generateDiscriminatedUnionValidation = (accessor, schemas, discriminatorKey, defaultValue, isRequired) => {
+  const cases = [];
+  for (const schema of schemas) {
+    const discriminatorValue = getDiscriminatorValue(schema, discriminatorKey);
+    if (discriminatorValue !== null) {
+      const schemaDefault = getDefaultValue(schema);
+      const checks = generateSchemaChecks(accessor, schema);
+      if (checks.length > 0) {
+        let combinedChecks = checks[0];
+        for (let i = 1;i < checks.length; i++) {
+          combinedChecks += " && " + checks[i];
+        }
+        cases.push(`${accessor}?.${discriminatorKey} === ${JSON.stringify(discriminatorValue)} && ${combinedChecks} ? ${accessor} : ${schemaDefault}`);
+      } else {
+        cases.push(`${accessor}?.${discriminatorKey} === ${JSON.stringify(discriminatorValue)} ? ${accessor} : ${schemaDefault}`);
+      }
+    }
+  }
+  if (cases.length === 0) {
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+  }
+  let result = cases[0];
+  for (let i = 1;i < cases.length; i++) {
+    result = cases[i] + " : " + result;
+  }
+  return result;
+};
+
+// src/generators/generate-non-discriminated-union-validation.ts
+var generateNonDiscriminatedUnionValidation = (accessor, schemas, defaultValue, isRequired) => {
+  const cases = [];
+  for (const schema of schemas) {
+    const checks = generateSchemaChecks(accessor, schema);
+    if (checks.length > 0) {
+      let combinedChecks = checks[0];
+      for (let i = 1;i < checks.length; i++) {
+        combinedChecks += " && " + checks[i];
+      }
+      cases.push("(" + combinedChecks + ")");
+    }
+  }
+  if (cases.length === 0) {
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+  }
+  let combinedCheck = cases[0];
+  for (let i = 1;i < cases.length; i++) {
+    combinedCheck += " || " + cases[i];
+  }
+  const finalDefault = isRequired ? defaultValue : "undefined";
+  return `(${combinedCheck}) ? ${accessor} : ${finalDefault}`;
+};
+
+// src/generators/generate-validation-expression.ts
+var getTypeCoercion = (accessor, schema, defaultValue) => {
+  if (!hasType(schema)) {
+    return null;
+  }
+  switch (schema.type) {
+    case "string":
+      return `String(${accessor})`;
+    case "number":
+    case "integer": {
+      const n = `Number(${accessor})`;
+      return `(Number.isFinite(${n}) ? ${n} : ${defaultValue})`;
+    }
+    case "boolean":
+      return `Boolean(${accessor})`;
+    case "array":
+      return `[]`;
+    case "object":
+      return `typeof ${accessor} === "object" && ${accessor} !== null ? ${accessor} : {}`;
+    default:
+      return null;
+  }
+};
+var generateValidationExpression = (key, schema, defaultValue, isRequired, rootSchema, visitedRefs, accessorOverride, knownNotUndefined) => {
+  const accessor = accessorOverride ?? safeAccessor("input?", key);
+  const checks = [];
+  if (!isSchemaObject3(schema)) {
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+  }
+  if (hasRef(schema) && rootSchema) {
+    const ref = schema.$ref;
+    if (visitedRefs?.has(ref)) {
+      return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+    }
+    const resolvedSchema = resolveRef(ref, rootSchema);
+    if (resolvedSchema) {
+      const visited = new Set(visitedRefs);
+      visited.add(ref);
+      return generateValidationExpression(key, resolvedSchema, defaultValue, isRequired, rootSchema, visited);
+    }
+  }
+  if (hasOneOf(schema) && schema.oneOf.length > 0) {
+    const discriminator = findDiscriminator(schema.oneOf);
+    if (discriminator) {
+      return generateDiscriminatedUnionValidation(accessor, schema.oneOf, discriminator, defaultValue, isRequired);
+    }
+    return generateNonDiscriminatedUnionValidation(accessor, schema.oneOf, defaultValue, isRequired);
+  }
+  if (hasAnyOf(schema) && schema.anyOf.length > 0) {
+    const discriminator = findDiscriminator(schema.anyOf);
+    if (discriminator) {
+      return generateDiscriminatedUnionValidation(accessor, schema.anyOf, discriminator, defaultValue, isRequired);
+    }
+    return generateNonDiscriminatedUnionValidation(accessor, schema.anyOf, defaultValue, isRequired);
+  }
+  if (hasAllOf(schema) && schema.allOf.length > 0) {
+    const allChecks = [];
+    for (const subSchema of schema.allOf) {
+      const subChecks = generateSchemaChecks(accessor, subSchema);
+      allChecks.push(...subChecks);
+    }
+    if (allChecks.length > 0) {
+      let combinedCheck2 = allChecks[0];
+      for (let i = 1;i < allChecks.length; i++) {
+        combinedCheck2 += " && " + allChecks[i];
+      }
+      return `${combinedCheck2} ? ${accessor} : ${defaultValue}`;
+    }
+    return `${accessor} ?? ${defaultValue}`;
+  }
+  if ("not" in schema && schema.not) {
+    const notChecks = generateSchemaChecks(accessor, schema.not);
+    if (notChecks.length > 0) {
+      let combinedNotCheck = notChecks[0];
+      for (let i = 1;i < notChecks.length; i++) {
+        combinedNotCheck += " && " + notChecks[i];
+      }
+      return `!(${combinedNotCheck}) ? ${accessor} : ${defaultValue}`;
+    }
+  }
+  if (hasConst(schema)) {
+    const constLiteral = JSON.stringify(schema.const);
+    return isRequired ? `${accessor} === ${constLiteral} ? ${accessor} : ${constLiteral}` : `${accessor} === ${constLiteral} ? ${accessor} : (${accessor} !== undefined ? ${constLiteral} : undefined)`;
+  }
+  if (!hasType(schema) && !hasEnum(schema)) {
+    return `${accessor} ?? ${defaultValue}`;
+  }
+  if (hasType(schema)) {
+    switch (schema.type) {
+      case "string": {
+        checks.push(`typeof ${accessor} === "string"`);
+        if (hasPattern(schema)) {
+          checks.push(`/${schema.pattern.replace(/\//g, "\\/")}/.test(${accessor})`);
+        }
+        if (hasMinLength(schema)) {
+          checks.push(`${accessor}.length >= ${schema.minLength}`);
+        }
+        if (hasMaxLength(schema)) {
+          checks.push(`${accessor}.length <= ${schema.maxLength}`);
+        }
+        break;
+      }
+      case "number":
+      case "integer": {
+        checks.push(`typeof ${accessor} === "number"`);
+        if (hasMinimum(schema)) {
+          checks.push(`${accessor} >= ${schema.minimum}`);
+        }
+        if (hasMaximum(schema)) {
+          checks.push(`${accessor} <= ${schema.maximum}`);
+        }
+        if (hasExclusiveMinimum(schema)) {
+          checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
+        }
+        if (hasExclusiveMaximum(schema)) {
+          checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
+        }
+        if (hasMultipleOf(schema)) {
+          checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+        }
+        break;
+      }
+      case "boolean":
+        checks.push(`typeof ${accessor} === "boolean"`);
+        break;
+      case "array": {
+        checks.push(`Array.isArray(${accessor})`);
+        if (hasMinItems(schema)) {
+          checks.push(`${accessor}.length >= ${schema.minItems}`);
+        }
+        if (hasMaxItems(schema)) {
+          checks.push(`${accessor}.length <= ${schema.maxItems}`);
+        }
+        if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+          checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+        }
+        break;
+      }
+      case "object": {
+        checks.push(`isObject(${accessor})`);
+        if (hasRequired(schema) && schema.required.length > 0) {
+          for (const requiredKey of schema.required) {
+            checks.push(`"${requiredKey}" in ${accessor}`);
+          }
+        }
+        if (hasMinProperties(schema)) {
+          checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
+        }
+        if (hasMaxProperties(schema)) {
+          checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
+        }
+        if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
+          const allowedKeys = Object.keys(schema.properties);
+          const allowedKeysStr = JSON.stringify(allowedKeys);
+          checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`);
+        }
+        break;
+      }
+    }
+  }
+  if (hasEnum(schema) && schema.enum.length > 0) {
+    checks.push(generateEnumCheck(accessor, schema.enum));
+  }
+  if (checks.length === 0) {
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+  }
+  let combinedCheck = checks[0];
+  for (let i = 1;i < checks.length; i++) {
+    combinedCheck += " && " + checks[i];
+  }
+  const typeCoercion = getTypeCoercion(accessor, schema, defaultValue);
+  if (isRequired) {
+    if (typeCoercion) {
+      if (knownNotUndefined) {
+        return `${combinedCheck} ? ${accessor} : ${typeCoercion}`;
+      }
+      return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : ${defaultValue})`;
+    }
+    return `${combinedCheck} ? ${accessor} : ${defaultValue}`;
+  } else {
+    if (typeCoercion) {
+      if (knownNotUndefined) {
+        return `${combinedCheck} ? ${accessor} : ${typeCoercion}`;
+      }
+      return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : undefined)`;
+    }
+    return `${combinedCheck} ? ${accessor} : undefined`;
+  }
+};
+
+// src/generators/generate-parser-function.ts
+var generateParserName = (typeName) => {
+  return `parse${typeName}`;
+};
+var isPropertyRequired = (key, schema) => {
+  if (!isSchemaObject3(schema)) {
+    return false;
+  }
+  if (!("required" in schema) || !Array.isArray(schema.required)) {
+    return false;
+  }
+  return schema.required.includes(key);
+};
+var generateRequiredRefCall = (key, ref) => {
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref));
+  return `${parserName}(${acc})`;
+};
+var generateOptionalRefCall = (key, ref) => {
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref));
+  return `...(${acc} && { ${safeKey2(key)}: ${parserName}(${acc}) })`;
+};
+var generateRequiredArrayRefCall = (key, ref) => {
+  const parserName = generateParserName(refToName(ref));
+  return `validateArray(${safeAccessor("input", key)}, ${parserName})`;
+};
+var generateOptionalArrayRefCall = (key, ref) => {
+  const parserName = generateParserName(refToName(ref));
+  const acc = safeAccessor("input", key);
+  return `...(${acc} && { ${safeKey2(key)}: validateArray(${acc}, ${parserName}) })`;
+};
+var generateRequiredRecordRefCall = (key, ref) => {
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref));
+  return `validateRecord(${acc}, ${parserName})`;
+};
+var generateOptionalRecordRefCall = (key, ref) => {
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref));
+  return `...(${acc} && { ${safeKey2(key)}: validateRecord(${acc}, ${parserName}) })`;
+};
+var generateOptionalInlineProperty = (key, valueExpression) => {
+  return `...((value => value === undefined ? {} : { ${safeKey2(key)}: value })(${valueExpression}))`;
+};
+var shouldUseRefImport = (propSchema, useRefImports) => {
+  if (!useRefImports || !hasRef(propSchema)) {
+    return false;
+  }
+  const ref = propSchema.$ref;
+  const isUri = ref.startsWith("http://") || ref.startsWith("https://");
+  if (isUri && (ref.includes("#/properties/") || ref.includes("#/definitions/"))) {
+    return false;
+  }
+  return true;
+};
+var shouldUseArrayRefImport = (propSchema, useRefImports) => {
+  if (!useRefImports) {
+    return false;
+  }
+  if (!isSchemaObject3(propSchema)) {
+    return false;
+  }
+  if (!("type" in propSchema) || propSchema.type !== "array") {
+    return false;
+  }
+  return hasItems(propSchema) && hasRef(propSchema.items);
+};
+var shouldUseRecordRefImport = (propSchema, useRefImports) => {
+  if (!useRefImports) {
+    return false;
+  }
+  if (!isSchemaObject3(propSchema)) {
+    return false;
+  }
+  if (!("type" in propSchema) || propSchema.type !== "object") {
+    return false;
+  }
+  if (!("additionalProperties" in propSchema)) {
+    return false;
+  }
+  const additionalProps = propSchema.additionalProperties;
+  return isSchemaObject3(additionalProps) && hasRef(additionalProps);
+};
+var generatePropertyValue = (key, propSchema, isRequired, useRefImports) => {
+  if (shouldUseRefImport(propSchema, useRefImports)) {
+    const ref = propSchema.$ref;
+    return isRequired ? generateRequiredRefCall(key, ref) : generateOptionalRefCall(key, ref);
+  }
+  if (shouldUseArrayRefImport(propSchema, useRefImports)) {
+    const items = propSchema.items;
+    const ref = items.$ref;
+    return isRequired ? generateRequiredArrayRefCall(key, ref) : generateOptionalArrayRefCall(key, ref);
+  }
+  if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+    const additionalProps = propSchema.additionalProperties;
+    const ref = additionalProps.$ref;
+    return isRequired ? generateRequiredRecordRefCall(key, ref) : generateOptionalRecordRefCall(key, ref);
+  }
+  if (!isSchemaObject3(propSchema)) {
+    return isRequired ? "undefined" : generateOptionalInlineProperty(key, "undefined");
+  }
+  const defaultValue = getDefaultValue(propSchema);
+  const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired);
+  return isRequired ? valueExpression : generateOptionalInlineProperty(key, valueExpression);
+};
+var generatePropertyEntries = (schema, useRefImports) => {
+  if (!hasProperties(schema)) {
+    return [];
+  }
+  const entries = [];
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const isRequired = isPropertyRequired(key, schema);
+    const value = generatePropertyValue(key, propSchema, isRequired, useRefImports);
+    const isOptional = value.startsWith("...");
+    entries.push({ key, value, isOptional });
+  }
+  return entries;
+};
+var generateFallbackValue = (_, propSchema, useRefImports) => {
+  if (useRefImports && hasRef(propSchema)) {
+    const ref = propSchema.$ref;
+    const parserName = generateParserName(refToName(ref));
+    return `${parserName}(undefined)`;
+  }
+  if (useRefImports && isSchemaObject3(propSchema) && propSchema.type === "array" && hasItems(propSchema) && hasRef(propSchema.items)) {
+    return "[]";
+  }
+  if (useRefImports && isSchemaObject3(propSchema) && propSchema.type === "object" && "additionalProperties" in propSchema) {
+    const additionalProps = propSchema.additionalProperties;
+    if (isSchemaObject3(additionalProps) && hasRef(additionalProps)) {
+      return "{}";
+    }
+  }
+  if (!isSchemaObject3(propSchema)) {
+    return "undefined";
+  }
+  if (hasDefault(propSchema)) {
+    return JSON.stringify(propSchema.default);
+  }
+  if (hasEnum(propSchema) && propSchema.enum.length > 0) {
+    return JSON.stringify(propSchema.enum[0]);
+  }
+  if (hasExamples(propSchema) && propSchema.examples.length > 0) {
+    return JSON.stringify(propSchema.examples[0]);
+  }
+  if (!hasType(propSchema)) {
+    return "undefined";
+  }
+  switch (propSchema.type) {
+    case "string":
+      return '""';
+    case "number":
+    case "integer":
+      return "0";
+    case "boolean":
+      return "false";
+    case "array":
+      return "[]";
+    case "object":
+      return "{}";
+    default:
+      return "undefined";
+  }
+};
+var generateFallbackObject = (schema, useRefImports, typeName) => {
+  if (!hasProperties(schema)) {
+    return `{} as ${typeName}`;
+  }
+  if (isSchemaObject3(schema) && (("if" in schema) || ("then" in schema) || ("else" in schema))) {
+    return `{} as ${typeName}`;
+  }
+  const requiredProps = [];
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const isRequired = isPropertyRequired(key, schema);
+    if (isRequired) {
+      const fallbackValue = generateFallbackValue(key, propSchema, useRefImports);
+      if (fallbackValue === "undefined") {
+        return `{} as ${typeName}`;
+      }
+      requiredProps.push(`        ${safeKey2(key)}: ${fallbackValue},`);
+    }
+  }
+  if (requiredProps.length === 0) {
+    return `{} as ${typeName}`;
+  }
+  let result = `{
+`;
+  for (let i = 0;i < requiredProps.length; i++) {
+    result += requiredProps[i];
+    if (i < requiredProps.length - 1) {
+      result += `
+`;
+    }
+  }
+  result += `
+      }`;
+  return result;
+};
+var generateNonObjectParser = (typeName, schema) => {
+  const functionName = generateParserName(typeName);
+  if (!isSchemaObject3(schema) || !hasType(schema)) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+  }
+  switch (schema.type) {
+    case "string":
+      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "string" ? input as ${typeName} : "" as ${typeName};`;
+    case "number":
+    case "integer":
+      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" ? input as ${typeName} : 0 as ${typeName};`;
+    case "boolean":
+      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "boolean" ? input as ${typeName} : false as ${typeName};`;
+    case "array":
+      return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? [...input] as ${typeName} : [] as ${typeName};`;
+    default:
+      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+  }
+};
+var generateEmptyObjectParser = (typeName) => {
+  const functionName = generateParserName(typeName);
+  return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {} as ${typeName};`;
+};
+var toVarName = (key) => {
+  const safe = key.replace(/[^a-zA-Z0-9_$]/g, "_");
+  return `_${safe}`;
+};
+var shapeValidatorName = (typeName) => `validate${typeName}Shape`;
+var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
+  if (!isSchemaObject3(schema))
+    return null;
+  if (useRefImports && hasRef(schema)) {
+    const refName = refToName(schema.$ref);
+    return `${shapeValidatorName(refName)}(${varName})`;
+  }
+  if (hasEnum(schema) || hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || hasRef(schema) || "not" in schema) {
+    return null;
+  }
+  if (!hasType(schema))
+    return null;
+  if (useRefImports && schema.type === "array" && hasItems(schema) && isSchemaObject3(schema.items) && hasRef(schema.items)) {
+    const refName = refToName(schema.items.$ref);
+    return `Array.isArray(${varName}) && ${varName}.every(${shapeValidatorName(refName)})`;
+  }
+  const checks = [];
+  switch (schema.type) {
+    case "string": {
+      checks.push(`typeof ${varName} === "string"`);
+      if (hasPattern(schema))
+        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${varName})`);
+      if (hasMinLength(schema))
+        checks.push(`${varName}.length >= ${schema.minLength}`);
+      if (hasMaxLength(schema))
+        checks.push(`${varName}.length <= ${schema.maxLength}`);
+      break;
+    }
+    case "number":
+    case "integer": {
+      checks.push(`typeof ${varName} === "number"`);
+      if (hasMinimum(schema))
+        checks.push(`${varName} >= ${schema.minimum}`);
+      if (hasMaximum(schema))
+        checks.push(`${varName} <= ${schema.maximum}`);
+      if (hasExclusiveMinimum(schema))
+        checks.push(`${varName} > ${schema.exclusiveMinimum}`);
+      if (hasExclusiveMaximum(schema))
+        checks.push(`${varName} < ${schema.exclusiveMaximum}`);
+      if (hasMultipleOf(schema))
+        checks.push(`${varName} % ${schema.multipleOf} === 0`);
+      break;
+    }
+    case "boolean":
+      checks.push(`typeof ${varName} === "boolean"`);
+      break;
+    case "array": {
+      checks.push(`Array.isArray(${varName})`);
+      if (hasMinItems(schema))
+        checks.push(`${varName}.length >= ${schema.minItems}`);
+      if (hasMaxItems(schema))
+        checks.push(`${varName}.length <= ${schema.maxItems}`);
+      if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+        checks.push(`new Set(${varName}).size === ${varName}.length`);
+      }
+      break;
+    }
+    case "object":
+      checks.push(`isObject(${varName})`);
+      break;
+    default:
+      return null;
+  }
+  if (checks.length === 0)
+    return null;
+  let result = checks[0];
+  for (let i = 1;i < checks.length; i++) {
+    result += " && " + checks[i];
+  }
+  return result;
+};
+var shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
+  return isSchemaObject3(propSchema);
+};
+var generateObjectParser = (schema, typeName, useRefImports, logWarnings) => {
+  const functionName = generateParserName(typeName);
+  if (!hasProperties(schema)) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
+  }
+  const fallbackObject = generateFallbackObject(schema, useRefImports, typeName);
+  const properties = Object.entries(schema.properties);
+  const lines = [];
+  lines.push(`export const ${functionName} = (input: unknown): ${typeName} => {`);
+  lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
+  const propInfo = [];
+  const hasAllOfRefParsers = useRefImports && isSchemaObject3(schema) && hasAllOf(schema) && schema.allOf.some((entry) => isSchemaObject3(entry) && hasRef(entry));
+  let canFastPath = !hasAllOfRefParsers;
+  const fastPathChecks = [];
+  for (const [key, propSchema] of properties) {
+    const isRequired = isPropertyRequired(key, schema);
+    const varName = toVarName(key);
+    propInfo.push({ key, varName, isRequired, propSchema });
+    if (canFastPath) {
+      if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+        canFastPath = false;
+      } else {
+        const check = generatePropertyTypeCheck(varName, propSchema, useRefImports);
+        if (check === null) {
+          canFastPath = false;
+        } else {
+          if (isRequired) {
+            fastPathChecks.push(check);
+          } else {
+            fastPathChecks.push(`(${varName} === undefined || ${check})`);
+          }
+        }
+      }
+    }
+  }
+  for (const { key, varName, propSchema } of propInfo) {
+    if (shouldCacheVariable(propSchema, canFastPath, useRefImports)) {
+      lines.push(`  const ${varName} = ${safeAccessor("input", key)};`);
+    }
+  }
+  if (logWarnings && propInfo.length > 0) {
+    const keysList = propInfo.map(({ key }) => JSON.stringify(key)).join(", ");
+    lines.push(`  const _knownKeys = new Set([${keysList}]);`);
+    lines.push(`  for (const _k in input) {`);
+    lines.push(`    if (!_knownKeys.has(_k)) {`);
+    lines.push(`      console.warn(\`[${typeName}] Unknown property "\${_k}"\`);`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+  }
+  if (canFastPath && fastPathChecks.length > 0) {
+    let fastPathExpr = fastPathChecks[0];
+    for (let i = 1;i < fastPathChecks.length; i++) {
+      fastPathExpr += " && " + fastPathChecks[i];
+    }
+    lines.push(`  if (${fastPathExpr}) return { ...input } as ${typeName};`);
+  }
+  const objectLines = [];
+  objectLines.push("    ...input,");
+  if (useRefImports && isSchemaObject3(schema) && hasAllOf(schema)) {
+    for (const entry of schema.allOf) {
+      if (isSchemaObject3(entry) && hasRef(entry)) {
+        const parserName = generateParserName(refToName(entry.$ref));
+        objectLines.push(`    ...(${parserName}(input) as Record<string, unknown>),`);
+      }
+    }
+  }
+  for (const { key, varName, isRequired, propSchema } of propInfo) {
+    const shouldCache = shouldCacheVariable(propSchema, canFastPath, useRefImports);
+    const accessor = shouldCache ? varName : safeAccessor("input", key);
+    if (shouldUseRefImport(propSchema, useRefImports)) {
+      const ref = propSchema.$ref;
+      const parserName = generateParserName(refToName(ref));
+      if (isRequired) {
+        objectLines.push(`    ${safeKey2(key)}: ${parserName}(${accessor}),`);
+      } else {
+        objectLines.push(`    ...(${accessor} !== undefined && { ${safeKey2(key)}: ${parserName}(${accessor}) }),`);
+      }
+      continue;
+    }
+    if (shouldUseArrayRefImport(propSchema, useRefImports)) {
+      const items = propSchema.items;
+      const ref = items.$ref;
+      const parserName = generateParserName(refToName(ref));
+      if (isRequired) {
+        objectLines.push(`    ${safeKey2(key)}: validateArray(${accessor}, ${parserName}),`);
+      } else {
+        objectLines.push(`    ...(${accessor} !== undefined && { ${safeKey2(key)}: validateArray(${accessor}, ${parserName}) }),`);
+      }
+      continue;
+    }
+    if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+      const additionalProps = propSchema.additionalProperties;
+      const ref = additionalProps.$ref;
+      const parserName = generateParserName(refToName(ref));
+      if (isRequired) {
+        objectLines.push(`    ${safeKey2(key)}: validateRecord(${accessor}, ${parserName}),`);
+      } else {
+        objectLines.push(`    ...(${accessor} !== undefined && { ${safeKey2(key)}: validateRecord(${accessor}, ${parserName}) }),`);
+      }
+      continue;
+    }
+    if (!isSchemaObject3(propSchema)) {
+      if (isRequired) {
+        objectLines.push(`    ${safeKey2(key)}: undefined,`);
+      }
+      continue;
+    }
+    const defaultValue = getDefaultValue(propSchema);
+    const knownNotUndefined = !isRequired;
+    const valueExpr = generateValidationExpression(key, propSchema, defaultValue, true, undefined, undefined, shouldCache ? varName : undefined, knownNotUndefined);
+    if (isRequired) {
+      objectLines.push(`    ${safeKey2(key)}: ${valueExpr},`);
+    } else {
+      objectLines.push(`    ...(${accessor} !== undefined && { ${safeKey2(key)}: ${valueExpr} }),`);
+    }
+  }
+  lines.push(`  return {`);
+  let objectBody = objectLines[0];
+  for (let i = 1;i < objectLines.length; i++) {
+    objectBody += `
+` + objectLines[i];
+  }
+  lines.push(objectBody);
+  lines.push(`  } as unknown as ${typeName};`);
+  lines.push(`}`);
+  let result = lines[0];
+  for (let i = 1;i < lines.length; i++) {
+    result += `
+` + lines[i];
+  }
+  return result;
+};
+var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings) => {
+  const functionName = generateParserName(typeName);
+  const entries = generatePropertyEntries(schema, useRefImports);
+  const propertyLines = entries.map((entry) => {
+    if (entry.isOptional) {
+      return `    ${entry.value},`;
+    }
+    return `    ${safeKey2(entry.key)}: ${entry.value},`;
+  });
+  if (!isSchemaObject3(schema) || !("patternProperties" in schema)) {
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+  }
+  const patternProps = schema.patternProperties;
+  const patterns = Object.entries(patternProps);
+  const refPattern = patterns.find(([, ps]) => isSchemaObject3(ps) && hasRef(ps));
+  if (!refPattern || !useRefImports) {
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+  }
+  const [pattern, patternSchema] = refPattern;
+  const ref = patternSchema.$ref;
+  const parserName = generateParserName(refToName(ref));
+  const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
+  const escapedPattern = escapeRegexPattern(pattern);
+  const inputSpread = "    ...input,";
+  let objectProperties = inputSpread;
+  if (propertyLines.length > 0) {
+    for (const line of propertyLines) {
+      objectProperties += `
+` + line;
+    }
+  }
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) {
+    return {} as unknown as ${typeName};
+  }
+  const result = {
+${objectProperties}
+  } as unknown as ${typeName};
+  for (const key in input) {
+    if (/${escapedPattern}/.test(key)) {
+      const value = input[key];
+      ${assignmentCode}
+    }
+  }
+  return result;
+};`;
+};
+var generateAdditionalPropertiesParser = (schema, typeName, useRefImports) => {
+  const functionName = generateParserName(typeName);
+  const additionalProps = schema.additionalProperties;
+  if (!additionalProps) {
+    return generateEmptyObjectParser(typeName);
+  }
+  if (useRefImports && isSchemaObject3(additionalProps) && hasRef(additionalProps)) {
+    const ref = additionalProps.$ref;
+    const parserName = generateParserName(refToName(ref));
+    return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${parserName}) as ${typeName};`;
+  }
+  if (isSchemaObject3(additionalProps) && hasType(additionalProps)) {
+    const inlineParser = generateInlineValueParser(additionalProps);
+    if (inlineParser) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${inlineParser}) as ${typeName};`;
+    }
+  }
+  return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {};`;
+};
+var generateInlineValueParser = (schema) => {
+  if (!isSchemaObject3(schema) || !hasType(schema)) {
+    return null;
+  }
+  switch (schema.type) {
+    case "string":
+      return '(value: unknown) => typeof value === "string" ? value : ""';
+    case "number":
+    case "integer":
+      return '(value: unknown) => typeof value === "number" ? value : 0';
+    case "boolean":
+      return '(value: unknown) => typeof value === "boolean" ? value : false';
+    case "array":
+      return "(value: unknown) => Array.isArray(value) ? value : []";
+    default:
+      return null;
+  }
+};
+var escapeRegexPattern = (pattern) => {
+  return pattern.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
+};
+var generatePatternPropertiesParser = (schema, typeName, useRefImports) => {
+  const functionName = generateParserName(typeName);
+  if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
+    return generateEmptyObjectParser(typeName);
+  }
+  const patternProps = schema.patternProperties;
+  const patterns = Object.entries(patternProps);
+  if (patterns.length === 0) {
+    return generateEmptyObjectParser(typeName);
+  }
+  const [pattern, patternSchema] = patterns[0];
+  let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
+  if (useRefImports && isSchemaObject3(patternSchema) && hasRef(patternSchema)) {
+    const ref = patternSchema.$ref;
+    const parserName = generateParserName(refToName(ref));
+    patternAssignment = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
+  } else if (patternSchema === false) {
+    patternAssignment = "";
+  }
+  const escapedPattern = escapeRegexPattern(pattern);
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) {
+    return {} as unknown as ${typeName};
+  }
+  const result = {
+    ...input,
+  } as unknown as ${typeName};
+  for (const key in input) {
+    if (/${escapedPattern}/.test(key)) {
+      const value = input[key];
+      ${patternAssignment}
+    }
+  }
+  return result;
+};`;
+};
+var generateConditionalParser = (schema, typeName) => {
+  const functionName = generateParserName(typeName);
+  const ifSchema = schema.if;
+  const thenSchema = schema.then;
+  const elseSchema = schema.else;
+  const thenHasRef = thenSchema && isSchemaObject3(thenSchema) && hasRef(thenSchema);
+  const elseHasRef = elseSchema && isSchemaObject3(elseSchema) && hasRef(elseSchema);
+  if (!thenHasRef || !elseHasRef) {
+    const mergedSchema = getConditionalObjectSchema2(schema);
+    if (mergedSchema) {
+      return generateObjectParser(mergedSchema, typeName, false);
+    }
+    return generateEmptyObjectParser(typeName);
+  }
+  const isRefCondition = ifSchema && isSchemaObject3(ifSchema) && "required" in ifSchema && Array.isArray(ifSchema.required) && ifSchema.required.includes("$ref");
+  if (!isRefCondition) {
+    const mergedSchema = getConditionalObjectSchema2(schema);
+    if (mergedSchema) {
+      return generateObjectParser(mergedSchema, typeName, false);
+    }
+    return generateEmptyObjectParser(typeName);
+  }
+  const thenRef = thenSchema.$ref;
+  const elseRef = elseSchema.$ref;
+  const thenParserName = generateParserName(refToName(thenRef));
+  const elseParserName = generateParserName(refToName(elseRef));
+  const thenTypeName = refToName(thenRef);
+  return `export const ${functionName} = (input: unknown): ${typeName} | ${thenTypeName} =>
+  hasRef(input) ? ${thenParserName}(input) : ${elseParserName}(input)
+      `;
+};
+var getConditionalObjectSchema2 = (schema) => {
+  if (!isSchemaObject3(schema)) {
+    return null;
+  }
+  if (!("if" in schema) || !("then" in schema)) {
+    return null;
+  }
+  const ifSchema = schema.if;
+  const thenSchema = schema.then;
+  const elseSchema = "else" in schema ? schema.else : undefined;
+  if (!isSchemaObject3(ifSchema) || !isSchemaObject3(thenSchema)) {
+    return null;
+  }
+  const ifProperties = ifSchema.properties;
+  const thenProperties = thenSchema.properties;
+  const elseProperties = elseSchema && isSchemaObject3(elseSchema) ? elseSchema.properties : undefined;
+  const hasIfProperties = ifProperties && typeof ifProperties === "object";
+  const hasThenProperties = thenProperties && typeof thenProperties === "object";
+  const hasElseProperties = elseProperties && typeof elseProperties === "object";
+  if (!hasIfProperties && !hasThenProperties && !hasElseProperties) {
+    return null;
+  }
+  const required = new Set;
+  if (Array.isArray(ifSchema.required)) {
+    for (const key of ifSchema.required) {
+      required.add(key);
+    }
+  }
+  if (hasIfProperties && ifProperties && typeof ifProperties === "object") {
+    for (const [key, propSchema] of Object.entries(ifProperties)) {
+      if (isSchemaObject3(propSchema) && hasConst(propSchema)) {
+        required.add(key);
+      }
+    }
+  }
+  if (Array.isArray(thenSchema.required)) {
+    for (const key of thenSchema.required) {
+      required.add(key);
+    }
+  }
+  return {
+    type: "object",
+    properties: {
+      ...hasElseProperties ? elseProperties : {},
+      ...hasIfProperties ? ifProperties : {},
+      ...hasThenProperties ? thenProperties : {}
+    },
+    ...required.size > 0 ? { required: Array.from(required) } : {}
+  };
+};
+var generateSchemaObjectParser = (typeName) => {
+  const functionName = generateParserName(typeName);
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (typeof input === 'boolean') {
+    return input as ${typeName};
+  }
+  
+  if (!isObject(input)) {
+    return {} as ${typeName};
+  }
+  
+  return input as ${typeName};
+};`;
+};
+var selectParserStrategy = (schema, typeName, options) => {
+  const useRefImports = options?.useRefImports ?? false;
+  const logWarnings = options?.logWarnings ?? false;
+  if (typeName === "SchemaObject") {
+    return generateSchemaObjectParser(typeName);
+  }
+  const isObjectLikeSchema2 = isObjectSchema2(schema) || isSchemaObject3(schema) && (("patternProperties" in schema) || ("additionalProperties" in schema));
+  if (!isObjectLikeSchema2 && !isSchemaObject3(schema)) {
+    return generateNonObjectParser(typeName, schema);
+  }
+  if (hasProperties(schema) && isSchemaObject3(schema) && "patternProperties" in schema) {
+    return generateCombinedObjectParser(schema, typeName, useRefImports, logWarnings);
+  }
+  if (hasProperties(schema)) {
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+  }
+  if (isSchemaObject3(schema) && "if" in schema && "then" in schema && "else" in schema) {
+    return generateConditionalParser(schema, typeName);
+  }
+  const conditionalObjectSchema = getConditionalObjectSchema2(schema);
+  if (conditionalObjectSchema) {
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, logWarnings);
+  }
+  if (!isObjectLikeSchema2) {
+    return generateNonObjectParser(typeName, schema);
+  }
+  if ("patternProperties" in schema) {
+    return generatePatternPropertiesParser(schema, typeName, useRefImports);
+  }
+  if ("additionalProperties" in schema && !hasProperties(schema)) {
+    const additionalProps = schema.additionalProperties;
+    if (additionalProps === true || additionalProps === false) {
+      return generateEmptyObjectParser(typeName);
+    }
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports);
+  }
+  if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
+    return generateEmptyObjectParser(typeName);
+  }
+  return generateEmptyObjectParser(typeName);
+};
+var generateParserFunction = (schema, typeName, options) => {
+  return selectParserStrategy(schema, typeName, options);
+};
+var generateShapeValidator = (schema, typeName, useRefImports) => {
+  const fnName = shapeValidatorName(typeName);
+  const stub = `export const ${fnName} = (_input: unknown): boolean => false;`;
+  if (!isSchemaObject3(schema))
+    return stub;
+  if (!hasProperties(schema))
+    return stub;
+  if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema || "patternProperties" in schema || "if" in schema || "then" in schema || "else" in schema) {
+    return stub;
+  }
+  const properties = Object.entries(schema.properties);
+  const checks = [];
+  for (const [key, propSchema] of properties) {
+    if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+      return stub;
+    }
+    const accessor = safeAccessor("input", key);
+    const isRequired = isPropertyRequired(key, schema);
+    const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports);
+    if (check === null) {
+      return stub;
+    }
+    if (isRequired) {
+      checks.push(check);
+    } else {
+      checks.push(`(${accessor} === undefined || ${check})`);
+    }
+  }
+  if (checks.length === 0) {
+    return `export const ${fnName} = (input: unknown): boolean => isObject(input);`;
+  }
+  let body = checks[0];
+  for (let i = 1;i < checks.length; i++) {
+    body += `
+    && ` + checks[i];
+  }
+  return `export const ${fnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;
+  return ${body};
+};`;
+};
+
+// src/generators/generate-files.ts
+var generateFile = (schema, typeName, options) => {
+  const typesOnly = options?.typesOnly === true;
+  const selfRef = options?.selfRef;
+  const rootSchema = options?.rootSchema;
+  const typeDefinition = generateTypeDefinition(schema, typeName);
+  if (typesOnly) {
+    const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema });
+    let result2 = "";
+    if (imports2.length > 0) {
+      result2 += imports2[0];
+      for (let i = 1;i < imports2.length; i++) {
+        result2 += `
+` + imports2[i];
+      }
+      result2 += `
+
+`;
+    }
+    return result2 + typeDefinition;
+  }
+  const parserFunction = generateParserFunction(schema, typeName, {
+    useRefImports: true,
+    ...options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {}
+  });
+  const shapeValidator = generateShapeValidator(schema, typeName, true);
+  const combinedFunctions = `${shapeValidator}
+
+${parserFunction}`;
+  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...collectHelpers(combinedFunctions)];
+  let result = "";
+  if (imports.length > 0) {
+    result += imports[0];
+    for (let i = 1;i < imports.length; i++) {
+      result += `
+` + imports[i];
+    }
+    result += `
+
+`;
+  }
+  return result + typeDefinition + `
+
+` + combinedFunctions;
+};
+
+// src/generators/build-schema.ts
+var extractDynamicAnchorDefs = (schema) => {
+  const refs = [];
+  if (typeof schema !== "object" || schema === null) {
+    return refs;
+  }
+  if (!("$defs" in schema) || typeof schema["$defs"] !== "object" || schema["$defs"] === null) {
+    return refs;
+  }
+  const defs = schema["$defs"];
+  for (const [key, value] of Object.entries(defs)) {
+    if (typeof value === "object" && value !== null) {
+      const defSchema = value;
+      if ("$dynamicAnchor" in defSchema) {
+        refs.push(`#/$defs/${key}`);
+      }
+    }
+  }
+  return refs;
+};
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings) => {
+  rootSchema = upgradeDraft07Schema(rootSchema);
+  const files = [];
+  const processedRefs = new Set;
+  const processedFilenames = new Set;
+  const refsToProcess = [];
+  const dynamicRefMap = buildDynamicRefMap(rootSchema);
+  const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap);
+  const extendedRootSchema = extensions ? applySchemaExtensions(processedRootSchema, rootTypeName.toLowerCase(), extensions) : processedRootSchema;
+  const rootContent = generateFile(extendedRootSchema, rootTypeName, {
+    typesOnly: typesOnly ?? false,
+    rootSchema,
+    ...logWarnings !== undefined ? { logWarnings } : {}
+  });
+  const rootFilename = rootTypeName.toLowerCase();
+  processedFilenames.add(rootFilename);
+  files.push({
+    filename: `${rootFilename}.ts`,
+    content: rootContent
+  });
+  const rootRefs = extractRefs(rootSchema);
+  refsToProcess.push(...rootRefs);
+  const dynamicAnchorRefs = extractDynamicAnchorDefs(rootSchema);
+  refsToProcess.push(...dynamicAnchorRefs);
+  while (refsToProcess.length > 0) {
+    const ref = refsToProcess.shift();
+    if (!ref || processedRefs.has(ref)) {
+      continue;
+    }
+    processedRefs.add(ref);
+    const resolvedSchema = resolveRef(ref, rootSchema);
+    if (!resolvedSchema) {
+      console.warn(`Warning: Could not resolve ref: ${ref}`);
+      continue;
+    }
+    const typeName = refToName(ref);
+    const filename = refToFilename(ref);
+    const processedSchema = resolveDynamicRefs(resolvedSchema, dynamicRefMap);
+    const extendedSchema = extensions ? applySchemaExtensions(processedSchema, filename, extensions) : processedSchema;
+    const content = generateFile(extendedSchema, typeName, {
+      typesOnly: typesOnly ?? false,
+      selfRef: ref,
+      rootSchema,
+      ...logWarnings !== undefined ? { logWarnings } : {}
+    });
+    if (!processedFilenames.has(filename)) {
+      processedFilenames.add(filename);
+      files.push({
+        filename: `${filename}.ts`,
+        content
+      });
+    }
+    const nestedRefs = extractRefs(resolvedSchema);
+    for (const nestedRef of nestedRefs) {
+      if (!processedRefs.has(nestedRef)) {
+        refsToProcess.push(nestedRef);
+      }
+    }
+  }
+  const TYPE_EXPORT_RE = /^export type (\w+)/gm;
+  const CONST_EXPORT_RE = /^export const (\w+)/gm;
+  const sortedFiles = [...files].sort((a, b) => a.filename.localeCompare(b.filename));
+  let indexContent = "";
+  for (const file of sortedFiles) {
+    const moduleName = file.filename.replace(/\.ts$/, "");
+    const typeNames = [];
+    const constNames = [];
+    for (const match of file.content.matchAll(TYPE_EXPORT_RE)) {
+      typeNames.push(match[1]);
+    }
+    for (const match of file.content.matchAll(CONST_EXPORT_RE)) {
+      constNames.push(match[1]);
+    }
+    if (typeNames.length === 0 && constNames.length === 0)
+      continue;
+    if (typesOnly) {
+      indexContent += `export type { ${typeNames.join(", ")} } from './${moduleName}';
+`;
+    } else {
+      const typeExports = typeNames.map((n) => `type ${n}`);
+      const allExports = [...typeExports, ...constNames];
+      indexContent += `export { ${allExports.join(", ")} } from './${moduleName}';
+`;
+    }
+  }
+  files.push({
+    filename: "index.ts",
+    content: indexContent
+  });
+  return files;
+};
+export {
+  buildSchema
+};