@takeshape/json-schema 11.52.0 → 11.55.0

package/dist/converters/schema-converter.js

@@ -1,662 +1,559 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SchemaConverter = exports.SchemaConversionTarget = void 0;
-var _util = require("@takeshape/util");
-var _intersection = _interopRequireDefault(require("lodash/intersection"));
-var _uniq = _interopRequireDefault(require("lodash/uniq"));
-var _minimatch = require("minimatch");
-var _utils = require("../utils");
-var _keys = require("../utils/keys");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-let SchemaConversionTarget = exports.SchemaConversionTarget = /*#__PURE__*/function (SchemaConversionTarget) {
-  SchemaConversionTarget["OpenAI"] = "OPENAI";
-  SchemaConversionTarget["JSONSchema"] = "JSON_SCHEMA";
-  return SchemaConversionTarget;
-}({});
-var SchemaProcessingMode = /*#__PURE__*/function (SchemaProcessingMode) {
-  SchemaProcessingMode["Schema"] = "SCHEMA";
-  SchemaProcessingMode["Definition"] = "DEFINITION";
-  SchemaProcessingMode["Count"] = "COUNT";
-  return SchemaProcessingMode;
-}(SchemaProcessingMode || {});
-class SchemaConverter {
-  warnings = [];
-  stats = {
-    propertiesCount: 0,
-    stringLength: 0,
-    enumValuesCount: 0
-  };
-  #schema;
-  #config;
-  #usedDefinitions = new Set();
-  #definitions = {};
-  #definitionsReferences = new Map();
-  static convert(schema, options = {}) {
-    return new SchemaConverter(schema, options).run();
-  }
-  constructor(originalSchema, options = {}) {
-    const {
-      removePropertyKeyPatterns,
-      target = SchemaConversionTarget.JSONSchema,
-      inlineDefinitions = false,
-      maxDepth = 5,
-      allowUnknownKeys = false
-    } = options;
-    this.#config = {
-      target,
-      maxDepth,
-      allowUnknownKeys,
-      removePropertyKeyPatterns: removePropertyKeyPatterns?.map(pattern => new _minimatch.Minimatch(pattern)) ?? [],
-      inlineDefinitions
+import { assert, ensureArray } from '@takeshape/util';
+import intersection from 'lodash/intersection.js';
+import uniq from 'lodash/uniq.js';
+import { Minimatch } from 'minimatch';
+import { getReferenceMap, isAllOfSchema, isAnyOfSchema, isArraySchema, isEnumSchema, isListSchema, isObjectSchema, isOneOfSchema, isPropertySchema, isRefSchema, isTupleSchema, pickJSONSchema7 } from "../utils/index.js";
+export var SchemaConversionTarget;
+(function (SchemaConversionTarget) {
+    SchemaConversionTarget["OpenAI"] = "OPENAI";
+    SchemaConversionTarget["JSONSchema"] = "JSON_SCHEMA";
+})(SchemaConversionTarget || (SchemaConversionTarget = {}));
+var SchemaProcessingMode;
+(function (SchemaProcessingMode) {
+    SchemaProcessingMode["Schema"] = "SCHEMA";
+    SchemaProcessingMode["Definition"] = "DEFINITION";
+    SchemaProcessingMode["Count"] = "COUNT";
+})(SchemaProcessingMode || (SchemaProcessingMode = {}));
+export class SchemaConverter {
+    warnings = [];
+    stats = {
+        propertiesCount: 0,
+        stringLength: 0,
+        enumValuesCount: 0
     };
-    const {
-      $defs,
-      definitions,
-      ...schema
-    } = originalSchema;
-    this.#schema = schema;
-    if ($defs || definitions) {
-      const defs = {
-        ...$defs,
-        ...definitions
-      };
-      this.#definitionsReferences = (0, _utils.getReferenceMap)(defs);
-      this.#definitions = this.processDefinitions(defs);
-    }
-  }
-  run() {
-    const {
-      target,
-      inlineDefinitions
-    } = this.#config;
-
-    // Process the schema
-    const result = this.processSchema({
-      processingMode: SchemaProcessingMode.Schema,
-      isRequired: true,
-      path: [],
-      depth: 0
-    }, this.#schema);
-    if (!inlineDefinitions && this.#usedDefinitions.size) {
-      const defs = this.getUsedDefinitions();
-      if (Object.keys(defs).length) {
-        result.$defs = defs;
-        this.countDefinitions(defs);
-      }
-    }
-
-    // Check the total property count
-    if (target === SchemaConversionTarget.OpenAI && this.stats.propertiesCount > 100) {
-      this.warnings.push(`Schema has ${this.stats.propertiesCount} total object properties, exceeding the 100 limit`);
-    }
-
-    // Check string length total
-    if (target === SchemaConversionTarget.OpenAI && this.stats.stringLength > 15000) {
-      this.warnings.push(`Total string length of property names, definition names, enum values exceeds the 15,000 limit (${this.stats.stringLength})`);
-    }
-
-    // Check enum values count
-    if (target === SchemaConversionTarget.OpenAI && this.stats.enumValuesCount > 500) {
-      this.warnings.push(`Schema has ${this.stats.enumValuesCount} enum values across all properties, exceeding the 500 limit`);
-    }
-
-    // Check if root is an object
-    if (target === SchemaConversionTarget.OpenAI && !(0, _utils.isPropertySchema)(result)) {
-      this.warnings.push('Root level must be an object type, wrapping in an object');
-
-      // Attempt to fix by wrapping in an object if possible
-      return {
-        schema: {
-          type: 'object',
-          properties: {
-            root: result
-          },
-          required: ['root'],
-          additionalProperties: false
-        },
-        warnings: this.warnings,
-        stats: this.stats
-      };
-    }
-    return {
-      schema: result,
-      warnings: this.warnings,
-      stats: this.stats
-    };
-  }
-  processSchema(context, schema) {
-    (0, _util.assert)(typeof schema === 'object', 'Schema must be an object');
-    const {
-      depth,
-      path,
-      isRequired,
-      processingMode
-    } = context;
-    const {
-      target,
-      maxDepth
-    } = this.#config;
-    // Clone the schema to avoid modifying the original
-    const schemaCopy = {
-      ...schema
-    };
-    const currentPath = path.join('.') || 'root';
-
-    // Check for unsupported keywords
-    this.checkUnsupportedKeywords(schemaCopy, currentPath);
-
-    // Check depth limit
-    if (depth > maxDepth) {
-      this.warnings.push(`Nesting depth exceeds limit (max 5) at ${currentPath}`);
-      // Simplify the schema at this level
-      return this.addNullable({
-        type: 'string',
-        description: 'Simplified due to excessive nesting'
-      }, isRequired);
-    }
-
-    // Handle $ref
-    if ((0, _utils.isRefSchema)(schemaCopy)) {
-      return this.processRefSchema(context, schemaCopy);
-    }
-
-    // Process specific types
-    if ((0, _utils.isObjectSchema)(schemaCopy) || (0, _utils.isPropertySchema)(schemaCopy)) {
-      return this.addNullable(this.processObjectSchema(context, schemaCopy), isRequired);
-    }
-    if ((0, _utils.isArraySchema)(schemaCopy)) {
-      return this.addNullable(this.processArraySchema(context, schemaCopy), isRequired);
-    }
-    if ((0, _utils.isAnyOfSchema)(schemaCopy)) {
-      return this.addNullable(this.processAnyOfSchema(context, schemaCopy), isRequired);
-    }
-    if ((0, _utils.isOneOfSchema)(schemaCopy)) {
-      if (target === SchemaConversionTarget.OpenAI) {
-        this.warnings.push(`oneOf at ${currentPath} converted to anyOf (OpenAI only supports anyOf)`);
-        const {
-          oneOf,
-          ...rest
-        } = schemaCopy;
-        return this.addNullable(this.processAnyOfSchema(context, {
-          ...rest,
-          anyOf: oneOf
-        }), isRequired);
-      }
-      return this.addNullable(this.processOneOfSchema(context, schemaCopy), isRequired);
-    }
-    if ((0, _utils.isAllOfSchema)(schemaCopy)) {
-      if (target === SchemaConversionTarget.OpenAI) {
-        this.warnings.push(`allOf at ${currentPath} is not directly supported, attempting to merge schemas`);
-        return this.addNullable(this.mergeAllOfSchema(context, schemaCopy), isRequired);
-      }
-      return this.addNullable(this.processAllOfSchema(context, schemaCopy), isRequired);
-    }
-    if ((0, _utils.isEnumSchema)(schemaCopy)) {
-      return this.addNullable(this.processEnumSchema(context, schemaCopy), isRequired);
-    }
-    if (target === SchemaConversionTarget.OpenAI && schemaCopy.default) {
-      const defaultText = `Default value: ${typeof schemaCopy.default === 'object' ? JSON.stringify(schemaCopy.default) : schemaCopy.default}`;
-      schemaCopy.description = schema.description ? `${schema.description} ${defaultText}` : defaultText;
-      // biome-ignore lint/performance/noDelete: don't want to leave cruft
-      delete schemaCopy.default;
-    }
-
-    // Update string length total for const values
-    if (schemaCopy.const && typeof schemaCopy.const === 'string' && (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count)) {
-      this.stats.stringLength += schemaCopy.const.length;
-    }
-    const newSchema = this.initializeNewSchema(schemaCopy, {
-      type: schemaCopy.type
-    });
-    return this.addNullable(newSchema, isRequired);
-  }
-  processDefinitions(defs) {
-    return Object.entries(defs).reduce((acc, [defName, def]) => {
-      acc[defName] = this.processSchema({
-        processingMode: SchemaProcessingMode.Definition,
-        isRequired: true,
-        path: [],
-        depth: 0
-      }, def);
-      return acc;
-    }, {});
-  }
-  countDefinitions(defs) {
-    for (const def of Object.values(defs)) {
-      this.processSchema({
-        processingMode: SchemaProcessingMode.Count,
-        isRequired: true,
-        path: [],
-        depth: 0
-      }, def);
-    }
-  }
-  getUsedDefinitions() {
-    const defs = {};
-    for (const usedDef of this.#usedDefinitions) {
-      this.addDefinition(defs, usedDef);
-
-      // Add any definitions that are referenced by the used definition
-      const defRefs = this.#definitionsReferences.get(usedDef);
-      if (defRefs) {
-        for (const ref of defRefs) {
-          this.addDefinition(defs, ref);
-        }
-      }
-    }
-    return defs;
-  }
-  addDefinition(defs, key) {
-    const definition = this.#definitions[key];
-    if (definition) {
-      this.stats.stringLength += key.length;
-      defs[key] = definition;
-    }
-  }
-  addNullable(schema, isRequired) {
-    if (this.#config.target === SchemaConversionTarget.JSONSchema) {
-      return schema;
-    }
-    if (isRequired) {
-      return schema;
+    #schema;
+    #config;
+    #usedDefinitions = new Set();
+    #definitions = {};
+    #definitionsReferences = new Map();
+    static convert(schema, options = {}) {
+        return new SchemaConverter(schema, options).run();
+    }
+    constructor(originalSchema, options = {}) {
+        const { removePropertyKeyPatterns, target = SchemaConversionTarget.JSONSchema, inlineDefinitions = false, maxDepth = 5, allowUnknownKeys = false } = options;
+        this.#config = {
+            target,
+            maxDepth,
+            allowUnknownKeys,
+            removePropertyKeyPatterns: removePropertyKeyPatterns?.map((pattern) => new Minimatch(pattern)) ?? [],
+            inlineDefinitions
+        };
+        const { $defs, definitions, ...schema } = originalSchema;
+        this.#schema = schema;
+        if ($defs || definitions) {
+            const defs = { ...$defs, ...definitions };
+            this.#definitionsReferences = getReferenceMap(defs);
+            this.#definitions = this.processDefinitions(defs);
+        }
     }
-    if (schema.type && !(0, _utils.isObjectSchema)(schema) && !(0, _utils.isArraySchema)(schema)) {
-      return {
-        ...schema,
-        type: (0, _uniq.default)([...(0, _util.ensureArray)(schema.type), 'null'])
-      };
+    run() {
+        const { target, inlineDefinitions } = this.#config;
+        // Process the schema
+        const result = this.processSchema({
+            processingMode: SchemaProcessingMode.Schema,
+            isRequired: true,
+            path: [],
+            depth: 0
+        }, this.#schema);
+        if (!inlineDefinitions && this.#usedDefinitions.size) {
+            const defs = this.getUsedDefinitions();
+            if (Object.keys(defs).length) {
+                result.$defs = defs;
+                this.countDefinitions(defs);
+            }
+        }
+        // Check the total property count
+        if (target === SchemaConversionTarget.OpenAI && this.stats.propertiesCount > 100) {
+            this.warnings.push(`Schema has ${this.stats.propertiesCount} total object properties, exceeding the 100 limit`);
+        }
+        // Check string length total
+        if (target === SchemaConversionTarget.OpenAI && this.stats.stringLength > 15000) {
+            this.warnings.push(`Total string length of property names, definition names, enum values exceeds the 15,000 limit (${this.stats.stringLength})`);
+        }
+        // Check enum values count
+        if (target === SchemaConversionTarget.OpenAI && this.stats.enumValuesCount > 500) {
+            this.warnings.push(`Schema has ${this.stats.enumValuesCount} enum values across all properties, exceeding the 500 limit`);
+        }
+        // Check if root is an object
+        if (target === SchemaConversionTarget.OpenAI && !isPropertySchema(result)) {
+            this.warnings.push('Root level must be an object type, wrapping in an object');
+            // Attempt to fix by wrapping in an object if possible
+            return {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        root: result
+                    },
+                    required: ['root'],
+                    additionalProperties: false
+                },
+                warnings: this.warnings,
+                stats: this.stats
+            };
+        }
+        return {
+            schema: result,
+            warnings: this.warnings,
+            stats: this.stats
+        };
     }
-    return {
-      anyOf: [...(schema.anyOf ? schema.anyOf : [schema]), {
-        type: 'null'
-      }]
-    };
-  }
-  processRefSchema(context, schema) {
-    const {
-      isRequired,
-      processingMode
-    } = context;
-    const newSchema = {
-      $ref: schema.$ref
-    };
-
-    // Normalize definitions path
-    if (newSchema.$ref.startsWith('#/definitions/')) {
-      newSchema.$ref = newSchema.$ref.replace('#/definitions/', '#/$defs/');
+    processSchema(context, schema) {
+        assert(typeof schema === 'object', 'Schema must be an object');
+        const { depth, path, isRequired, processingMode } = context;
+        const { target, maxDepth } = this.#config;
+        // Clone the schema to avoid modifying the original
+        const schemaCopy = { ...schema };
+        const currentPath = path.join('.') || 'root';
+        // Check for unsupported keywords
+        this.checkUnsupportedKeywords(schemaCopy, currentPath);
+        // Check depth limit
+        if (depth > maxDepth) {
+            this.warnings.push(`Nesting depth exceeds limit (max 5) at ${currentPath}`);
+            // Simplify the schema at this level
+            return this.addNullable({ type: 'string', description: 'Simplified due to excessive nesting' }, isRequired);
+        }
+        // Handle $ref
+        if (isRefSchema(schemaCopy)) {
+            return this.processRefSchema(context, schemaCopy);
+        }
+        // Process specific types
+        if (isObjectSchema(schemaCopy) || isPropertySchema(schemaCopy)) {
+            return this.addNullable(this.processObjectSchema(context, schemaCopy), isRequired);
+        }
+        if (isArraySchema(schemaCopy)) {
+            return this.addNullable(this.processArraySchema(context, schemaCopy), isRequired);
+        }
+        if (isAnyOfSchema(schemaCopy)) {
+            return this.addNullable(this.processAnyOfSchema(context, schemaCopy), isRequired);
+        }
+        if (isOneOfSchema(schemaCopy)) {
+            if (target === SchemaConversionTarget.OpenAI) {
+                this.warnings.push(`oneOf at ${currentPath} converted to anyOf (OpenAI only supports anyOf)`);
+                const { oneOf, ...rest } = schemaCopy;
+                return this.addNullable(this.processAnyOfSchema(context, { ...rest, anyOf: oneOf }), isRequired);
+            }
+            return this.addNullable(this.processOneOfSchema(context, schemaCopy), isRequired);
+        }
+        if (isAllOfSchema(schemaCopy)) {
+            if (target === SchemaConversionTarget.OpenAI) {
+                this.warnings.push(`allOf at ${currentPath} is not directly supported, attempting to merge schemas`);
+                return this.addNullable(this.mergeAllOfSchema(context, schemaCopy), isRequired);
+            }
+            return this.addNullable(this.processAllOfSchema(context, schemaCopy), isRequired);
+        }
+        if (isEnumSchema(schemaCopy)) {
+            return this.addNullable(this.processEnumSchema(context, schemaCopy), isRequired);
+        }
+        if (target === SchemaConversionTarget.OpenAI && schemaCopy.default) {
+            const defaultText = `Default value: ${typeof schemaCopy.default === 'object' ? JSON.stringify(schemaCopy.default) : schemaCopy.default}`;
+            schemaCopy.description = schema.description ? `${schema.description} ${defaultText}` : defaultText;
+            // biome-ignore lint/performance/noDelete: don't want to leave cruft
+            delete schemaCopy.default;
+        }
+        // Update string length total for const values
+        if (schemaCopy.const &&
+            typeof schemaCopy.const === 'string' &&
+            (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count)) {
+            this.stats.stringLength += schemaCopy.const.length;
+        }
+        const newSchema = this.initializeNewSchema(schemaCopy, {
+            type: schemaCopy.type
+        });
+        return this.addNullable(newSchema, isRequired);
+    }
+    processDefinitions(defs) {
+        return Object.entries(defs).reduce((acc, [defName, def]) => {
+            acc[defName] = this.processSchema({
+                processingMode: SchemaProcessingMode.Definition,
+                isRequired: true,
+                path: [],
+                depth: 0
+            }, def);
+            return acc;
+        }, {});
+    }
+    countDefinitions(defs) {
+        for (const def of Object.values(defs)) {
+            this.processSchema({
+                processingMode: SchemaProcessingMode.Count,
+                isRequired: true,
+                path: [],
+                depth: 0
+            }, def);
+        }
     }
-    const defName = newSchema.$ref.replace('#/$defs/', '');
-    if (defName && this.#config.inlineDefinitions && this.#definitions[defName]) {
-      return this.processSchema(context, this.#definitions[defName]);
+    getUsedDefinitions() {
+        const defs = {};
+        for (const usedDef of this.#usedDefinitions) {
+            this.addDefinition(defs, usedDef);
+            // Add any definitions that are referenced by the used definition
+            const defRefs = this.#definitionsReferences.get(usedDef);
+            if (defRefs) {
+                for (const ref of defRefs) {
+                    this.addDefinition(defs, ref);
+                }
+            }
+        }
+        return defs;
     }
-    if (processingMode === SchemaProcessingMode.Schema) {
-      this.#usedDefinitions.add(defName);
+    addDefinition(defs, key) {
+        const definition = this.#definitions[key];
+        if (definition) {
+            this.stats.stringLength += key.length;
+            defs[key] = definition;
+        }
     }
-    return this.addNullable(newSchema, isRequired);
-  }
-  initializeNewSchema(schema, newSchema) {
-    // OpenAI will only allow some very specific properties, so start fairly clean
-    if (this.#config.target === SchemaConversionTarget.OpenAI) {
-      let base = {
-        title: schema.title,
-        description: schema.description
-      };
-      if (newSchema.type === 'object') {
-        base = {
-          ...base,
-          required: Object.keys(newSchema.properties ?? schema.properties ?? {}),
-          additionalProperties: false
+    addNullable(schema, isRequired) {
+        if (this.#config.target === SchemaConversionTarget.JSONSchema) {
+            return schema;
+        }
+        if (isRequired) {
+            return schema;
+        }
+        if (schema.type && !isObjectSchema(schema) && !isArraySchema(schema)) {
+            return {
+                ...schema,
+                type: uniq([...ensureArray(schema.type), 'null'])
+            };
+        }
+        return {
+            anyOf: [...(schema.anyOf ? schema.anyOf : [schema]), { type: 'null' }]
         };
-      } else if (newSchema.type === 'array') {
-        base = {
-          ...base,
-          items: []
+    }
+    processRefSchema(context, schema) {
+        const { isRequired, processingMode } = context;
+        const newSchema = {
+            $ref: schema.$ref
         };
-      } else if (newSchema.type === 'number' || newSchema.type === 'integer' || newSchema.type === 'string' || newSchema.type === 'boolean') {
-        base = {
-          ...base,
-          const: schema.const
+        // Normalize definitions path
+        if (newSchema.$ref.startsWith('#/definitions/')) {
+            newSchema.$ref = newSchema.$ref.replace('#/definitions/', '#/$defs/');
+        }
+        const defName = newSchema.$ref.replace('#/$defs/', '');
+        if (defName && this.#config.inlineDefinitions && this.#definitions[defName]) {
+            return this.processSchema(context, this.#definitions[defName]);
+        }
+        if (processingMode === SchemaProcessingMode.Schema) {
+            this.#usedDefinitions.add(defName);
+        }
+        return this.addNullable(newSchema, isRequired);
+    }
+    initializeNewSchema(schema, newSchema) {
+        // OpenAI will only allow some very specific properties, so start fairly clean
+        if (this.#config.target === SchemaConversionTarget.OpenAI) {
+            let base = {
+                title: schema.title,
+                description: schema.description
+            };
+            if (newSchema.type === 'object') {
+                base = {
+                    ...base,
+                    required: Object.keys(newSchema.properties ?? schema.properties ?? {}),
+                    additionalProperties: false
+                };
+            }
+            else if (newSchema.type === 'array') {
+                base = {
+                    ...base,
+                    items: []
+                };
+            }
+            else if (newSchema.type === 'number' ||
+                newSchema.type === 'integer' ||
+                newSchema.type === 'string' ||
+                newSchema.type === 'boolean') {
+                base = {
+                    ...base,
+                    const: schema.const
+                };
+            }
+            return {
+                ...base,
+                ...newSchema
+            };
+        }
+        return {
+            // We may be converting a schema with non-spec properties
+            ...(this.#config.allowUnknownKeys ? schema : pickJSONSchema7(schema)),
+            ...newSchema
         };
-      }
-      return {
-        ...base,
-        ...newSchema
-      };
     }
-    return {
-      // We may be converting a schema with non-spec properties
-      ...(this.#config.allowUnknownKeys ? schema : (0, _keys.pickJSONSchema7)(schema)),
-      ...newSchema
-    };
-  }
-  processObjectSchema(context, schema) {
-    const {
-      depth,
-      path,
-      processingMode
-    } = context;
-    const {
-      target,
-      removePropertyKeyPatterns
-    } = this.#config;
-    const newSchema = this.initializeNewSchema(schema, {
-      type: 'object'
-    });
-    const uniqueRequired = new Set(schema.required ?? []);
-    const newSchemaProperties = {};
-
-    // Process properties
-    if (schema.properties) {
-      // Process each property
-      for (const [key, property] of Object.entries(schema.properties)) {
-        // Skip properties that match removePropertyKeyPatterns
-        if (removePropertyKeyPatterns.length && removePropertyKeyPatterns.some(pattern => pattern.match(key))) {
-          continue;
-        }
-        newSchemaProperties[key] = this.processSchema({
-          ...context,
-          path: [...path, key],
-          depth: depth + 1,
-          isRequired: uniqueRequired.has(key)
-        }, property);
-
-        // Update string length total for property names
+    processObjectSchema(context, schema) {
+        const { depth, path, processingMode } = context;
+        const { target, removePropertyKeyPatterns } = this.#config;
+        const newSchema = this.initializeNewSchema(schema, {
+            type: 'object'
+        });
+        const uniqueRequired = new Set(schema.required ?? []);
+        const newSchemaProperties = {};
+        // Process properties
+        if (schema.properties) {
+            // Process each property
+            for (const [key, property] of Object.entries(schema.properties)) {
+                // Skip properties that match removePropertyKeyPatterns
+                if (removePropertyKeyPatterns.length && removePropertyKeyPatterns.some((pattern) => pattern.match(key))) {
+                    continue;
+                }
+                newSchemaProperties[key] = this.processSchema({
+                    ...context,
+                    path: [...path, key],
+                    depth: depth + 1,
+                    isRequired: uniqueRequired.has(key)
+                }, property);
+                // Update string length total for property names
+                if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
+                    this.stats.stringLength += key.length;
+                }
+            }
+        }
+        const newPropertyKeys = Object.keys(newSchemaProperties);
+        // Update total property count
         if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-          this.stats.stringLength += key.length;
+            this.stats.propertiesCount += newPropertyKeys.length;
         }
-      }
-    }
-    const newPropertyKeys = Object.keys(newSchemaProperties);
-
-    // Update total property count
-    if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-      this.stats.propertiesCount += newPropertyKeys.length;
-    }
-    let required = schema.required;
-    if (target === SchemaConversionTarget.OpenAI) {
-      // OpenAI requires all properties to be required
-      required = newPropertyKeys;
-    } else if (required) {
-      required = (0, _intersection.default)([...uniqueRequired], newPropertyKeys);
-    }
-    return {
-      ...newSchema,
-      properties: newSchemaProperties,
-      // Make all properties required for openai target, for json-schema some may have been removed
-      required
-    };
-  }
-  processArraySchema(context, schema) {
-    const {
-      depth,
-      path
-    } = context;
-    const newSchema = this.initializeNewSchema(schema, {
-      type: 'array'
-    });
-
-    // Process items schema
-    if (schema.items) {
-      if ((0, _utils.isTupleSchema)(schema)) {
-        newSchema.items = schema.items.map((item, index) => this.processSchema({
-          ...context,
-          path: [...path, 'items', index],
-          depth: depth + 1
-        }, item));
-      }
-      if ((0, _utils.isListSchema)(schema)) {
-        newSchema.items = this.processSchema({
-          ...context,
-          path: [...path, 'items'],
-          depth: depth + 1
-        }, schema.items);
-      }
-    } else {
-      this.warnings.push(`Array missing items definition at ${path.join('.') || 'root'}, defaulting to string items`);
-      newSchema.items = {
-        type: 'string'
-      };
-    }
-    for (const keyword of this.getUnsupportedArrayKeywords()) {
-      if (schema[keyword] !== undefined) {
-        this.warnings.push(`Unsupported array keyword "${keyword}" at ${path.join('.') || 'root'} will be ignored`);
-      }
-    }
-    return newSchema;
-  }
-  getUnsupportedArrayKeywords() {
-    if (this.#config.target === SchemaConversionTarget.OpenAI) {
-      return [
-      // 'unevaluatedItems',
-      'contains',
-      // 'minContains',
-      // 'maxContains',
-      'minItems', 'maxItems', 'uniqueItems'];
-    }
-    return [];
-  }
-  processOneOfSchema(context, schema) {
-    const {
-      depth,
-      path
-    } = context;
-    const newSchema = this.initializeNewSchema(schema, {
-      oneOf: []
-    });
-
-    // Process each oneOf schema
-    newSchema.oneOf = schema.oneOf.map((subSchema, index) => {
-      return this.processSchema({
-        ...context,
-        path: [...path, 'oneOf', index],
-        depth: depth + 1
-      }, subSchema);
-    });
-    return newSchema;
-  }
-  processAnyOfSchema(context, schema) {
-    const {
-      target
-    } = this.#config;
-    const {
-      depth,
-      path
-    } = context;
-    const newSchema = this.initializeNewSchema(schema, {
-      anyOf: []
-    });
-
-    // Check if this is at the root level
-    if (target === SchemaConversionTarget.OpenAI && path.length === 0) {
-      this.warnings.push('anyOf at root level is not supported by OpenAI Structured Outputs');
-    }
-
-    // Process each anyOf schema
-    newSchema.anyOf = schema.anyOf.map((subSchema, index) => {
-      return this.processSchema({
-        ...context,
-        path: [...path, 'anyOf', index],
-        depth: depth + 1
-      }, subSchema);
-    });
-    return newSchema;
-  }
-  processAllOfSchema(context, schema) {
-    const {
-      depth,
-      path
-    } = context;
-    const newSchema = this.initializeNewSchema(schema, {
-      allOf: []
-    });
-
-    // Process each anyOf schema
-    newSchema.allOf = schema.allOf.map((subSchema, index) => {
-      return this.processSchema({
-        ...context,
-        path: [...path, 'allOf', index],
-        depth: depth + 1
-      }, subSchema);
-    });
-    return newSchema;
-  }
-  mergeAllOfSchema(context, schema) {
-    const {
-      depth,
-      path
-    } = context;
-    const newSchema = this.initializeNewSchema(schema, {
-      type: 'object'
-    });
-    const allOfSchemas = schema.allOf ?? [];
-
-    // Try to merge properties from all schemas
-    for (const [index, value] of allOfSchemas.entries()) {
-      const subSchema = this.processSchema({
-        ...context,
-        path: [...path, 'allOf', index]
-      }, value);
-      if ((0, _utils.isObjectSchema)(subSchema) && (0, _utils.isPropertySchema)(subSchema)) {
-        // Merge properties
-        newSchema.properties = {
-          ...newSchema.properties,
-          ...subSchema.properties
+        let required = schema.required;
+        if (target === SchemaConversionTarget.OpenAI) {
+            // OpenAI requires all properties to be required
+            required = newPropertyKeys;
+        }
+        else if (required) {
+            required = intersection([...uniqueRequired], newPropertyKeys);
+        }
+        return {
+            ...newSchema,
+            properties: newSchemaProperties,
+            // Make all properties required for openai target, for json-schema some may have been removed
+            required
         };
-
-        // Merge required fields
-        if (Array.isArray(subSchema.required)) {
-          newSchema.required = [...(newSchema.required ?? []), ...subSchema.required];
-        }
-
-        // Preserve description if we don't have one yet
-        if (!newSchema.description && subSchema.description) {
-          newSchema.description = subSchema.description;
-        }
-
-        // Preserve title if we don't have one yet
-        if (!newSchema.title && subSchema.title) {
-          newSchema.title = subSchema.title;
-        }
-      } else {
-        this.warnings.push(`Non-object schema in allOf at ${path.join('.') || 'root'} cannot be merged properly`);
-      }
     }
-
-    // Remove duplicate required fields
-    newSchema.required = [...new Set(newSchema.required)];
-    return this.processObjectSchema({
-      ...context,
-      depth: depth + 1
-    }, newSchema);
-  }
-  processEnumSchema(context, schema) {
-    const {
-      target
-    } = this.#config;
-    const {
-      path,
-      processingMode
-    } = context;
-    const newSchema = this.initializeNewSchema(schema, {
-      enum: schema.enum,
-      type: schema.type
-    });
-    if (Array.isArray(newSchema.enum)) {
-      // Update enum values count
-      if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-        this.stats.enumValuesCount += newSchema.enum.length;
-      }
-
-      // Check enum size
-      if (target === SchemaConversionTarget.OpenAI && newSchema.enum.length > 500) {
-        this.warnings.push(`Enum at ${path.join('.') || 'root'} has ${newSchema.enum.length} values, exceeding the 500 limit`);
-        newSchema.enum = newSchema.enum.slice(0, 500);
-      }
-
-      // Check string length for large enums
-      if (newSchema.type === 'string') {
-        let totalLength = 0;
-        for (const val of newSchema.enum) {
-          if (typeof val === 'string') {
-            totalLength += val.length;
-          }
-        }
-        if (target === SchemaConversionTarget.OpenAI && totalLength > 7500) {
-          this.warnings.push(`Enum strings at ${path.join('.') || 'root'} exceed 7500 characters (${totalLength}) with ${newSchema.enum.length} values`);
-
-          // Truncate enum values to fit within limits
-          let currentLength = 0;
-          const truncatedEnum = [];
-          for (const val of newSchema.enum) {
-            if (typeof val === 'string') {
-              if (currentLength + val.length <= 7500) {
-                truncatedEnum.push(val);
-                currentLength += val.length;
-              } else {
-                break;
-              }
-            } else {
-              truncatedEnum.push(val);
+    processArraySchema(context, schema) {
+        const { depth, path } = context;
+        const newSchema = this.initializeNewSchema(schema, {
+            type: 'array'
+        });
+        // Process items schema
+        if (schema.items) {
+            if (isTupleSchema(schema)) {
+                newSchema.items = schema.items.map((item, index) => this.processSchema({
+                    ...context,
+                    path: [...path, 'items', index],
+                    depth: depth + 1
+                }, item));
+            }
+            if (isListSchema(schema)) {
+                newSchema.items = this.processSchema({
+                    ...context,
+                    path: [...path, 'items'],
+                    depth: depth + 1
+                }, schema.items);
             }
-          }
-          newSchema.enum = truncatedEnum;
         }
-        if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-          this.stats.stringLength += totalLength;
+        else {
+            this.warnings.push(`Array missing items definition at ${path.join('.') || 'root'}, defaulting to string items`);
+            newSchema.items = { type: 'string' };
+        }
+        for (const keyword of this.getUnsupportedArrayKeywords()) {
+            if (schema[keyword] !== undefined) {
+                this.warnings.push(`Unsupported array keyword "${keyword}" at ${path.join('.') || 'root'} will be ignored`);
+            }
+        }
+        return newSchema;
+    }
+    getUnsupportedArrayKeywords() {
+        if (this.#config.target === SchemaConversionTarget.OpenAI) {
+            return [
+                // 'unevaluatedItems',
+                'contains',
+                // 'minContains',
+                // 'maxContains',
+                'minItems',
+                'maxItems',
+                'uniqueItems'
+            ];
+        }
+        return [];
+    }
+    processOneOfSchema(context, schema) {
+        const { depth, path } = context;
+        const newSchema = this.initializeNewSchema(schema, {
+            oneOf: []
+        });
+        // Process each oneOf schema
+        newSchema.oneOf = schema.oneOf.map((subSchema, index) => {
+            return this.processSchema({ ...context, path: [...path, 'oneOf', index], depth: depth + 1 }, subSchema);
+        });
+        return newSchema;
+    }
+    processAnyOfSchema(context, schema) {
+        const { target } = this.#config;
+        const { depth, path } = context;
+        const newSchema = this.initializeNewSchema(schema, {
+            anyOf: []
+        });
+        // Check if this is at the root level
+        if (target === SchemaConversionTarget.OpenAI && path.length === 0) {
+            this.warnings.push('anyOf at root level is not supported by OpenAI Structured Outputs');
+        }
+        // Process each anyOf schema
+        newSchema.anyOf = schema.anyOf.map((subSchema, index) => {
+            return this.processSchema({ ...context, path: [...path, 'anyOf', index], depth: depth + 1 }, subSchema);
+        });
+        return newSchema;
+    }
+    processAllOfSchema(context, schema) {
+        const { depth, path } = context;
+        const newSchema = this.initializeNewSchema(schema, {
+            allOf: []
+        });
+        // Process each anyOf schema
+        newSchema.allOf = schema.allOf.map((subSchema, index) => {
+            return this.processSchema({ ...context, path: [...path, 'allOf', index], depth: depth + 1 }, subSchema);
+        });
+        return newSchema;
+    }
+    mergeAllOfSchema(context, schema) {
+        const { depth, path } = context;
+        const newSchema = this.initializeNewSchema(schema, {
+            type: 'object'
+        });
+        const allOfSchemas = schema.allOf ?? [];
+        // Try to merge properties from all schemas
+        for (const [index, value] of allOfSchemas.entries()) {
+            const subSchema = this.processSchema({ ...context, path: [...path, 'allOf', index] }, value);
+            if (isObjectSchema(subSchema) && isPropertySchema(subSchema)) {
+                // Merge properties
+                newSchema.properties = {
+                    ...newSchema.properties,
+                    ...subSchema.properties
+                };
+                // Merge required fields
+                if (Array.isArray(subSchema.required)) {
+                    newSchema.required = [...(newSchema.required ?? []), ...subSchema.required];
+                }
+                // Preserve description if we don't have one yet
+                if (!newSchema.description && subSchema.description) {
+                    newSchema.description = subSchema.description;
+                }
+                // Preserve title if we don't have one yet
+                if (!newSchema.title && subSchema.title) {
+                    newSchema.title = subSchema.title;
+                }
+            }
+            else {
+                this.warnings.push(`Non-object schema in allOf at ${path.join('.') || 'root'} cannot be merged properly`);
+            }
+        }
+        // Remove duplicate required fields
+        newSchema.required = [...new Set(newSchema.required)];
+        return this.processObjectSchema({ ...context, depth: depth + 1 }, newSchema);
+    }
+    processEnumSchema(context, schema) {
+        const { target } = this.#config;
+        const { path, processingMode } = context;
+        const newSchema = this.initializeNewSchema(schema, {
+            enum: schema.enum,
+            type: schema.type
+        });
+        if (Array.isArray(newSchema.enum)) {
+            // Update enum values count
+            if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
+                this.stats.enumValuesCount += newSchema.enum.length;
+            }
+            // Check enum size
+            if (target === SchemaConversionTarget.OpenAI && newSchema.enum.length > 500) {
+                this.warnings.push(`Enum at ${path.join('.') || 'root'} has ${newSchema.enum.length} values, exceeding the 500 limit`);
+                newSchema.enum = newSchema.enum.slice(0, 500);
+            }
+            // Check string length for large enums
+            if (newSchema.type === 'string') {
+                let totalLength = 0;
+                for (const val of newSchema.enum) {
+                    if (typeof val === 'string') {
+                        totalLength += val.length;
+                    }
+                }
+                if (target === SchemaConversionTarget.OpenAI && totalLength > 7500) {
+                    this.warnings.push(`Enum strings at ${path.join('.') || 'root'} exceed 7500 characters (${totalLength}) with ${newSchema.enum.length} values`);
+                    // Truncate enum values to fit within limits
+                    let currentLength = 0;
+                    const truncatedEnum = [];
+                    for (const val of newSchema.enum) {
+                        if (typeof val === 'string') {
+                            if (currentLength + val.length <= 7500) {
+                                truncatedEnum.push(val);
+                                currentLength += val.length;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        else {
+                            truncatedEnum.push(val);
+                        }
+                    }
+                    newSchema.enum = truncatedEnum;
+                }
+                if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
+                    this.stats.stringLength += totalLength;
+                }
+            }
+        }
+        return newSchema;
+    }
+    checkUnsupportedKeywords(schema, path) {
+        if (this.#config.target === SchemaConversionTarget.OpenAI) {
+            // String-specific unsupported keywords
+            if (schema.type === 'string' ||
+                (!schema.type &&
+                    (schema.minLength !== undefined ||
+                        schema.maxLength !== undefined ||
+                        schema.pattern !== undefined ||
+                        schema.format !== undefined))) {
+                const unsupportedStringKeywords = ['minLength', 'maxLength', 'pattern', 'format'];
+                for (const keyword of unsupportedStringKeywords) {
+                    if (schema[keyword] !== undefined) {
+                        this.warnings.push(`Unsupported string keyword "${keyword}" at ${path || 'root'} will be ignored`);
+                        delete schema[keyword];
+                    }
+                }
+            }
+            // Number-specific unsupported keywords
+            if (schema.type === 'number' ||
+                schema.type === 'integer' ||
+                (!schema.type &&
+                    (schema.minimum !== undefined || schema.maximum !== undefined || schema.multipleOf !== undefined))) {
+                const unsupportedNumberKeywords = ['minimum', 'maximum', 'multipleOf'];
+                for (const keyword of unsupportedNumberKeywords) {
+                    if (schema[keyword] !== undefined) {
+                        this.warnings.push(`Unsupported number keyword "${keyword}" at ${path || 'root'} will be ignored`);
+                        delete schema[keyword];
+                    }
+                }
+            }
+            // Object-specific unsupported keywords
+            if (schema.type === 'object' || (!schema.type && schema.properties !== undefined)) {
+                const unsupportedObjectKeywords = [
+                    'patternProperties',
+                    // 'unevaluatedProperties',
+                    'propertyNames',
+                    'minProperties',
+                    'maxProperties'
+                ];
+                for (const keyword of unsupportedObjectKeywords) {
+                    if (schema[keyword] !== undefined) {
+                        this.warnings.push(`Unsupported object keyword "${keyword}" at ${path || 'root'} will be ignored`);
+                        delete schema[keyword];
+                    }
+                }
+            }
+            // Check Draft 7 keywords that aren't supported in OpenAI schema
+            const draft7Keywords = ['if', 'then', 'else', 'not', 'dependencies'];
+            for (const keyword of draft7Keywords) {
+                if (schema[keyword] !== undefined) {
+                    this.warnings.push(`JSON Schema Draft 7 keyword "${keyword}" at ${path || 'root'} is not supported and will be ignored`);
+                    delete schema[keyword];
+                }
+            }
         }
-      }
-    }
-    return newSchema;
-  }
-  checkUnsupportedKeywords(schema, path) {
-    if (this.#config.target === SchemaConversionTarget.OpenAI) {
-      // String-specific unsupported keywords
-      if (schema.type === 'string' || !schema.type && (schema.minLength !== undefined || schema.maxLength !== undefined || schema.pattern !== undefined || schema.format !== undefined)) {
-        const unsupportedStringKeywords = ['minLength', 'maxLength', 'pattern', 'format'];
-        for (const keyword of unsupportedStringKeywords) {
-          if (schema[keyword] !== undefined) {
-            this.warnings.push(`Unsupported string keyword "${keyword}" at ${path || 'root'} will be ignored`);
-            delete schema[keyword];
-          }
-        }
-      }
-
-      // Number-specific unsupported keywords
-      if (schema.type === 'number' || schema.type === 'integer' || !schema.type && (schema.minimum !== undefined || schema.maximum !== undefined || schema.multipleOf !== undefined)) {
-        const unsupportedNumberKeywords = ['minimum', 'maximum', 'multipleOf'];
-        for (const keyword of unsupportedNumberKeywords) {
-          if (schema[keyword] !== undefined) {
-            this.warnings.push(`Unsupported number keyword "${keyword}" at ${path || 'root'} will be ignored`);
-            delete schema[keyword];
-          }
-        }
-      }
-
-      // Object-specific unsupported keywords
-      if (schema.type === 'object' || !schema.type && schema.properties !== undefined) {
-        const unsupportedObjectKeywords = ['patternProperties',
-        // 'unevaluatedProperties',
-        'propertyNames', 'minProperties', 'maxProperties'];
-        for (const keyword of unsupportedObjectKeywords) {
-          if (schema[keyword] !== undefined) {
-            this.warnings.push(`Unsupported object keyword "${keyword}" at ${path || 'root'} will be ignored`);
-            delete schema[keyword];
-          }
-        }
-      }
-
-      // Check Draft 7 keywords that aren't supported in OpenAI schema
-      const draft7Keywords = ['if', 'then', 'else', 'not', 'dependencies'];
-      for (const keyword of draft7Keywords) {
-        if (schema[keyword] !== undefined) {
-          this.warnings.push(`JSON Schema Draft 7 keyword "${keyword}" at ${path || 'root'} is not supported and will be ignored`);
-          delete schema[keyword];
-        }
-      }
     }
-  }
 }
-exports.SchemaConverter = SchemaConverter;