@kubb/plugin-oas 3.10.10 → 3.10.12

package/dist/{chunk-7U6BHIOO.cjs → chunk-WAB2O4DX.cjs}

@@ -1,5 +1,6 @@
 'use strict';
 
+var chunkYWMMI3MO_cjs = require('./chunk-YWMMI3MO.cjs');
 var chunkZVFL3NXX_cjs = require('./chunk-ZVFL3NXX.cjs');
 var core = require('@kubb/core');
 var transformers = require('@kubb/core/transformers');
@@ -11,58 +12,6 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var transformers__default = /*#__PURE__*/_interopDefault(transformers);
 
-// src/SchemaMapper.ts
-var schemaKeywords = {
-  any: "any",
-  unknown: "unknown",
-  number: "number",
-  integer: "integer",
-  string: "string",
-  boolean: "boolean",
-  undefined: "undefined",
-  nullable: "nullable",
-  null: "null",
-  nullish: "nullish",
-  array: "array",
-  tuple: "tuple",
-  enum: "enum",
-  union: "union",
-  datetime: "datetime",
-  date: "date",
-  email: "email",
-  uuid: "uuid",
-  url: "url",
-  void: "void",
-  /* intersection */
-  default: "default",
-  const: "const",
-  and: "and",
-  describe: "describe",
-  min: "min",
-  max: "max",
-  optional: "optional",
-  readOnly: "readOnly",
-  writeOnly: "writeOnly",
-  // custom ones
-  object: "object",
-  ref: "ref",
-  matches: "matches",
-  firstName: "firstName",
-  lastName: "lastName",
-  password: "password",
-  phone: "phone",
-  blob: "blob",
-  deprecated: "deprecated",
-  example: "example",
-  schema: "schema",
-  catchall: "catchall",
-  time: "time",
-  name: "name",
-  interface: "interface"
-};
-function isKeyword(meta, keyword) {
-  return meta.keyword === keyword;
-}
 var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
   // Collect the types of all referenced schemas, so we can export them later
   refs = {};
@@ -91,7 +40,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
       if (schema.keyword === keyword) {
         foundItems.push(schema);
       }
-      if (isKeyword(schema, schemaKeywords.object)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.object)) {
         Object.values(schema.args?.properties || {}).forEach((entrySchema) => {
           foundItems.push(..._SchemaGenerator.deepSearch(entrySchema, keyword));
         });
@@ -99,22 +48,22 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
           foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
         });
       }
-      if (isKeyword(schema, schemaKeywords.array)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.array)) {
         schema.args.items.forEach((entrySchema) => {
           foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
         });
       }
-      if (isKeyword(schema, schemaKeywords.and)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.and)) {
         schema.args.forEach((entrySchema) => {
           foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
         });
       }
-      if (isKeyword(schema, schemaKeywords.tuple)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.tuple)) {
         schema.args.items.forEach((entrySchema) => {
           foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
         });
       }
-      if (isKeyword(schema, schemaKeywords.union)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.union)) {
         schema.args.forEach((entrySchema) => {
           foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
         });
@@ -123,12 +72,12 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     return foundItems;
   }
   static findInObject(tree, keyword) {
-    let foundItem = void 0;
+    let foundItem;
     tree?.forEach((schema) => {
       if (!foundItem && schema.keyword === keyword) {
         foundItem = schema;
       }
-      if (isKeyword(schema, schemaKeywords.object)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.object)) {
         Object.values(schema.args?.properties || {}).forEach((entrySchema) => {
           if (!foundItem) {
             foundItem = _SchemaGenerator.find(entrySchema, keyword);
@@ -144,33 +93,33 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     return foundItem;
   }
   static find(tree, keyword) {
-    let foundItem = void 0;
+    let foundItem;
     tree?.forEach((schema) => {
       if (!foundItem && schema.keyword === keyword) {
         foundItem = schema;
       }
-      if (isKeyword(schema, schemaKeywords.array)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.array)) {
         schema.args.items.forEach((entrySchema) => {
           if (!foundItem) {
             foundItem = _SchemaGenerator.find([entrySchema], keyword);
           }
         });
       }
-      if (isKeyword(schema, schemaKeywords.and)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.and)) {
         schema.args.forEach((entrySchema) => {
           if (!foundItem) {
             foundItem = _SchemaGenerator.find([entrySchema], keyword);
           }
         });
       }
-      if (isKeyword(schema, schemaKeywords.tuple)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.tuple)) {
         schema.args.items.forEach((entrySchema) => {
           if (!foundItem) {
             foundItem = _SchemaGenerator.find([entrySchema], keyword);
           }
         });
       }
-      if (isKeyword(schema, schemaKeywords.union)) {
+      if (chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.union)) {
         schema.args.forEach((entrySchema) => {
           if (!foundItem) {
             foundItem = _SchemaGenerator.find([entrySchema], keyword);
@@ -199,12 +148,12 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
   #getUnknownReturn(props) {
     const options = this.#getOptions(props);
     if (options.unknownType === "any") {
-      return schemaKeywords.any;
+      return chunkYWMMI3MO_cjs.schemaKeywords.any;
     }
     if (options.unknownType === "void") {
-      return schemaKeywords.void;
+      return chunkYWMMI3MO_cjs.schemaKeywords.void;
     }
-    return schemaKeywords.unknown;
+    return chunkYWMMI3MO_cjs.schemaKeywords.unknown;
   }
   /**
    * Recursively creates a type literal with the given props.
@@ -220,13 +169,13 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
       const nullable = propertySchema.nullable ?? propertySchema["x-nullable"] ?? false;
       validationFunctions.push(...this.parse({ schemaObject: propertySchema, name: propertyName, parentName: name }));
       validationFunctions.push({
-        keyword: schemaKeywords.name,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.name,
         args: propertyName
       });
       if (!isRequired && nullable) {
-        validationFunctions.push({ keyword: schemaKeywords.nullish });
+        validationFunctions.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.nullish });
       } else if (!isRequired) {
-        validationFunctions.push({ keyword: schemaKeywords.optional });
+        validationFunctions.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.optional });
       }
       return {
         [propertyName]: validationFunctions
@@ -238,7 +187,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     }
     return [
       {
-        keyword: schemaKeywords.object,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.object,
         args: {
           properties: propertiesSchemas,
           additionalProperties: additionalPropertiesSchemas
@@ -259,19 +208,19 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
         if (key) {
           return [
             {
-              keyword: schemaKeywords.and,
+              keyword: chunkYWMMI3MO_cjs.schemaKeywords.and,
               args: [
                 {
-                  keyword: schemaKeywords.ref,
+                  keyword: chunkYWMMI3MO_cjs.schemaKeywords.ref,
                   args: { name: ref.propertyName, $ref, path: ref.path, isImportable: !!this.context.oas.get($ref) }
                 },
                 {
-                  keyword: schemaKeywords.object,
+                  keyword: chunkYWMMI3MO_cjs.schemaKeywords.object,
                   args: {
                     properties: {
                       [dereferencedSchema.discriminator.propertyName]: [
                         {
-                          keyword: schemaKeywords.const,
+                          keyword: chunkYWMMI3MO_cjs.schemaKeywords.const,
                           args: {
                             name: key,
                             format: "string",
@@ -289,7 +238,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
       }
       return [
         {
-          keyword: schemaKeywords.ref,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.ref,
           args: { name: ref.propertyName, $ref, path: ref.path, isImportable: !!this.context.oas.get($ref) }
         }
       ];
@@ -325,47 +274,40 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     schemaObject,
     discriminator
   }) {
-    if (!isKeyword(schema, schemaKeywords.union)) {
+    if (!chunkYWMMI3MO_cjs.isKeyword(schema, chunkYWMMI3MO_cjs.schemaKeywords.union)) {
       return schema;
     }
-    const objectPropertySchema = _SchemaGenerator.find(this.parse({ schemaObject }), schemaKeywords.object);
+    const objectPropertySchema = _SchemaGenerator.find(this.parse({ schemaObject }), chunkYWMMI3MO_cjs.schemaKeywords.object);
     return {
       ...schema,
-      args: schema.args.map((arg) => {
-        const isRef = isKeyword(arg, schemaKeywords.ref);
-        if (isRef) {
-          const [key] = Object.entries(discriminator.mapping || {}).find(([_key, value]) => value === arg.args.$ref) || [];
-          if (!key) {
-            throw new Error(`Can not find a key in discriminator ${JSON.stringify(schema)}`);
-          }
-          return {
-            keyword: schemaKeywords.and,
-            args: [
-              arg,
-              {
-                keyword: schemaKeywords.object,
-                args: {
-                  properties: {
-                    ...objectPropertySchema?.args?.properties || {},
-                    [discriminator.propertyName]: [
-                      {
-                        keyword: schemaKeywords.const,
-                        args: {
-                          name: key,
-                          format: "string",
-                          value: key
-                        }
-                      },
-                      //enum and literal will conflict
-                      ...objectPropertySchema?.args?.properties[discriminator.propertyName] || []
-                    ].filter((item) => !isKeyword(item, schemaKeywords.enum))
-                  }
+      args: Object.entries(discriminator.mapping || {}).map(([key, value]) => {
+        const arg = schema.args.find((item) => chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.ref) && item.args.$ref === value);
+        return {
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.and,
+          args: [
+            arg,
+            {
+              keyword: chunkYWMMI3MO_cjs.schemaKeywords.object,
+              args: {
+                properties: {
+                  ...objectPropertySchema?.args?.properties || {},
+                  [discriminator.propertyName]: [
+                    {
+                      keyword: chunkYWMMI3MO_cjs.schemaKeywords.const,
+                      args: {
+                        name: key,
+                        format: "string",
+                        value: key
+                      }
+                    },
+                    //enum and literal will conflict
+                    ...objectPropertySchema?.args?.properties[discriminator.propertyName] || []
+                  ].filter((item) => !chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.enum))
                 }
               }
-            ]
-          };
-        }
-        return arg;
+            }
+          ]
+        };
       })
     };
   }
@@ -382,7 +324,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     }
     const baseItems = [
       {
-        keyword: schemaKeywords.schema,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.schema,
         args: {
           type: schemaObject.type,
           format: schemaObject.format
@@ -396,81 +338,81 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     if (schemaObject.default !== void 0 && !defaultNullAndNullable && !Array.isArray(schemaObject.default)) {
       if (typeof schemaObject.default === "string") {
         baseItems.push({
-          keyword: schemaKeywords.default,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.default,
           args: transformers__default.default.stringify(schemaObject.default)
         });
       } else if (typeof schemaObject.default === "boolean") {
         baseItems.push({
-          keyword: schemaKeywords.default,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.default,
           args: schemaObject.default ?? false
         });
       } else {
         baseItems.push({
-          keyword: schemaKeywords.default,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.default,
           args: schemaObject.default
         });
       }
     }
     if (schemaObject.deprecated) {
       baseItems.push({
-        keyword: schemaKeywords.deprecated
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.deprecated
       });
     }
     if (schemaObject.description) {
       baseItems.push({
-        keyword: schemaKeywords.describe,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.describe,
         args: schemaObject.description
       });
     }
     if (max !== void 0) {
-      baseItems.unshift({ keyword: schemaKeywords.max, args: max });
+      baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.max, args: max });
     }
     if (min !== void 0) {
-      baseItems.unshift({ keyword: schemaKeywords.min, args: min });
+      baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.min, args: min });
     }
     if (nullable) {
-      baseItems.push({ keyword: schemaKeywords.nullable });
+      baseItems.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.nullable });
     }
     if (schemaObject.type && Array.isArray(schemaObject.type)) {
       const items = schemaObject.type.filter((value) => value !== "null");
       const hasNull = schemaObject.type.includes("null");
       if (hasNull && !nullable) {
-        baseItems.push({ keyword: schemaKeywords.nullable });
+        baseItems.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.nullable });
       }
       if (items.length > 1) {
         const parsedItems = [
           {
-            keyword: schemaKeywords.union,
+            keyword: chunkYWMMI3MO_cjs.schemaKeywords.union,
             args: items.map(
               (item) => this.parse({
                 schemaObject: { ...schemaObject, type: item },
                 name,
                 parentName
               })[0]
-            ).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown)).map((item) => isKeyword(item, schemaKeywords.object) ? { ...item, args: { ...item.args, strict: true } } : item)
+            ).filter(Boolean).filter((item) => !chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.unknown)).map((item) => chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.object) ? { ...item, args: { ...item.args, strict: true } } : item)
           }
         ];
         return [...parsedItems, ...baseItems].filter(Boolean);
       }
     }
     if (schemaObject.readOnly) {
-      baseItems.push({ keyword: schemaKeywords.readOnly });
+      baseItems.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.readOnly });
     }
     if (schemaObject.writeOnly) {
-      baseItems.push({ keyword: schemaKeywords.writeOnly });
+      baseItems.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.writeOnly });
     }
     if (oas.isReference(schemaObject)) {
       return [
         ...this.#getRefAlias(schemaObject, name),
         schemaObject.description && {
-          keyword: schemaKeywords.describe,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.describe,
           args: schemaObject.description
         },
-        nullable && { keyword: schemaKeywords.nullable },
-        schemaObject.readOnly && { keyword: schemaKeywords.readOnly },
-        schemaObject.writeOnly && { keyword: schemaKeywords.writeOnly },
+        nullable && { keyword: chunkYWMMI3MO_cjs.schemaKeywords.nullable },
+        schemaObject.readOnly && { keyword: chunkYWMMI3MO_cjs.schemaKeywords.readOnly },
+        schemaObject.writeOnly && { keyword: chunkYWMMI3MO_cjs.schemaKeywords.writeOnly },
         {
-          keyword: schemaKeywords.schema,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.schema,
           args: {
             type: schemaObject.type,
             format: schemaObject.format
@@ -480,13 +422,13 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     }
     if (schemaObject.oneOf) {
       const schemaWithoutOneOf = { ...schemaObject, oneOf: void 0 };
+      const discriminator = this.context.oas.getDiscriminator(schemaObject);
       const union = {
-        keyword: schemaKeywords.union,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.union,
         args: schemaObject.oneOf.map((item) => {
           return item && this.parse({ schemaObject: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown))
+        }).filter(Boolean).filter((item) => !chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.unknown))
       };
-      const discriminator = this.context.oas.getDiscriminator(schemaObject);
       if (discriminator) {
         return [this.#addDiscriminatorToSchema({ schemaObject: schemaWithoutOneOf, schema: union, discriminator }), ...baseItems];
       }
@@ -495,7 +437,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
         union.args = [
           ...union.args.map((arg) => {
             return {
-              keyword: schemaKeywords.and,
+              keyword: chunkYWMMI3MO_cjs.schemaKeywords.and,
               args: [arg, ...propertySchemas]
             };
           })
@@ -507,11 +449,11 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     if (schemaObject.anyOf) {
       const schemaWithoutAnyOf = { ...schemaObject, anyOf: void 0 };
       const union = {
-        keyword: schemaKeywords.union,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.union,
         args: schemaObject.anyOf.map((item) => {
           return item && this.parse({ schemaObject: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown)).map((item) => {
-          if (isKeyword(item, schemaKeywords.object)) {
+        }).filter(Boolean).filter((item) => !chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.unknown)).map((item) => {
+          if (chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.object)) {
             return {
               ...item,
               args: {
@@ -532,7 +474,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
         union.args = [
           ...union.args.map((arg) => {
             return {
-              keyword: schemaKeywords.and,
+              keyword: chunkYWMMI3MO_cjs.schemaKeywords.and,
               args: [arg, ...propertySchemas]
             };
           })
@@ -544,10 +486,10 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
     if (schemaObject.allOf) {
       const schemaWithoutAllOf = { ...schemaObject, allOf: void 0 };
       const and = {
-        keyword: schemaKeywords.and,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.and,
         args: schemaObject.allOf.map((item) => {
           return item && this.parse({ schemaObject: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown))
+        }).filter(Boolean).filter((item) => !chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.unknown))
       };
       if (schemaWithoutAllOf.required) {
         const schemas = schemaObject.allOf.map((item) => {
@@ -591,13 +533,13 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
       });
       const nullableEnum = schemaObject.enum.includes(null);
       if (nullableEnum) {
-        baseItems.push({ keyword: schemaKeywords.nullable });
+        baseItems.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.nullable });
       }
       const filteredValues = schemaObject.enum.filter((value) => value !== null);
       const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schemaObject).map((extensionKey) => {
         return [
           {
-            keyword: schemaKeywords.enum,
+            keyword: chunkYWMMI3MO_cjs.schemaKeywords.enum,
             args: {
               name,
               typeName,
@@ -610,15 +552,15 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
             }
           },
           ...baseItems.filter(
-            (item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches
+            (item) => item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.min && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.max && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.matches
           )
         ];
       });
       if (schemaObject.type === "number" || schemaObject.type === "integer") {
-        const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
+        const enumNames = extensionEnums[0]?.find((item) => chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.enum));
         return [
           {
-            keyword: schemaKeywords.enum,
+            keyword: chunkYWMMI3MO_cjs.schemaKeywords.enum,
             args: {
               name: enumName,
               typeName,
@@ -636,14 +578,14 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
               })
             }
           },
-          ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)
+          ...baseItems.filter((item) => item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.min && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.max && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.matches)
         ];
       }
       if (schemaObject.type === "boolean") {
-        const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
+        const enumNames = extensionEnums[0]?.find((item) => chunkYWMMI3MO_cjs.isKeyword(item, chunkYWMMI3MO_cjs.schemaKeywords.enum));
         return [
           {
-            keyword: schemaKeywords.enum,
+            keyword: chunkYWMMI3MO_cjs.schemaKeywords.enum,
             args: {
               name: enumName,
               typeName,
@@ -661,7 +603,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
               })
             }
           },
-          ...baseItems.filter((item) => item.keyword !== schemaKeywords.matches)
+          ...baseItems.filter((item) => item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.matches)
         ];
       }
       if (extensionEnums.length > 0 && extensionEnums[0]) {
@@ -669,7 +611,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
       }
       return [
         {
-          keyword: schemaKeywords.enum,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.enum,
           args: {
             name: enumName,
             typeName,
@@ -681,7 +623,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
             }))
           }
         },
-        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)
+        ...baseItems.filter((item) => item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.min && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.max && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.matches)
       ];
     }
     if ("prefixItems" in schemaObject) {
@@ -691,7 +633,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
       const max2 = schemaObject.maximum ?? schemaObject.maxLength ?? schemaObject.maxItems ?? void 0;
       return [
         {
-          keyword: schemaKeywords.tuple,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.tuple,
           args: {
             min: min2,
             max: max2,
@@ -705,14 +647,14 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
             })[0]
           }
         },
-        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
+        ...baseItems.filter((item) => item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.min && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.max)
       ];
     }
     if (version === "3.1" && "const" in schemaObject) {
       if (schemaObject["const"]) {
         return [
           {
-            keyword: schemaKeywords.const,
+            keyword: chunkYWMMI3MO_cjs.schemaKeywords.const,
             args: {
               name: schemaObject["const"],
               format: typeof schemaObject["const"] === "number" ? "number" : "string",
@@ -722,65 +664,65 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
           ...baseItems
         ];
       }
-      return [{ keyword: schemaKeywords.null }];
+      return [{ keyword: chunkYWMMI3MO_cjs.schemaKeywords.null }];
     }
     if (schemaObject.format) {
       if (schemaObject.type === "integer" && (schemaObject.format === "int32" || schemaObject.format === "int64")) {
-        baseItems.unshift({ keyword: schemaKeywords.integer });
+        baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.integer });
         return baseItems;
       }
       if (schemaObject.type === "number" && (schemaObject.format === "float" || schemaObject.format === "double")) {
-        baseItems.unshift({ keyword: schemaKeywords.number });
+        baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.number });
         return baseItems;
       }
       switch (schemaObject.format) {
         case "binary":
-          baseItems.push({ keyword: schemaKeywords.blob });
+          baseItems.push({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.blob });
           return baseItems;
         case "date-time":
           if (options.dateType) {
             if (options.dateType === "date") {
-              baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "date" } });
+              baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.date, args: { type: "date" } });
               return baseItems;
             }
             if (options.dateType === "stringOffset") {
-              baseItems.unshift({ keyword: schemaKeywords.datetime, args: { offset: true } });
+              baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.datetime, args: { offset: true } });
               return baseItems;
             }
             if (options.dateType === "stringLocal") {
-              baseItems.unshift({ keyword: schemaKeywords.datetime, args: { local: true } });
+              baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.datetime, args: { local: true } });
               return baseItems;
             }
-            baseItems.unshift({ keyword: schemaKeywords.datetime, args: { offset: false } });
+            baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.datetime, args: { offset: false } });
             return baseItems;
           }
           break;
         case "date":
           if (options.dateType) {
             if (options.dateType === "date") {
-              baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "date" } });
+              baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.date, args: { type: "date" } });
               return baseItems;
             }
-            baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "string" } });
+            baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.date, args: { type: "string" } });
             return baseItems;
           }
           break;
         case "time":
           if (options.dateType) {
             if (options.dateType === "date") {
-              baseItems.unshift({ keyword: schemaKeywords.time, args: { type: "date" } });
+              baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.time, args: { type: "date" } });
               return baseItems;
             }
-            baseItems.unshift({ keyword: schemaKeywords.time, args: { type: "string" } });
+            baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.time, args: { type: "string" } });
             return baseItems;
           }
           break;
         case "uuid":
-          baseItems.unshift({ keyword: schemaKeywords.uuid });
+          baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.uuid });
           return baseItems;
         case "email":
         case "idn-email":
-          baseItems.unshift({ keyword: schemaKeywords.email });
+          baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.email });
           return baseItems;
         case "uri":
         case "ipv4":
@@ -788,13 +730,13 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
         case "uri-reference":
         case "hostname":
         case "idn-hostname":
-          baseItems.unshift({ keyword: schemaKeywords.url });
+          baseItems.unshift({ keyword: chunkYWMMI3MO_cjs.schemaKeywords.url });
           return baseItems;
       }
     }
     if (schemaObject.pattern && schemaObject.type === "string") {
       baseItems.unshift({
-        keyword: schemaKeywords.matches,
+        keyword: chunkYWMMI3MO_cjs.schemaKeywords.matches,
         args: schemaObject.pattern
       });
       return baseItems;
@@ -806,7 +748,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
       const unique = !!schemaObject.uniqueItems;
       return [
         {
-          keyword: schemaKeywords.array,
+          keyword: chunkYWMMI3MO_cjs.schemaKeywords.array,
           args: {
             items,
             min: min2,
@@ -814,7 +756,7 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
             unique
           }
         },
-        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
+        ...baseItems.filter((item) => item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.min && item.keyword !== chunkYWMMI3MO_cjs.schemaKeywords.max)
       ];
     }
     if (schemaObject.properties || schemaObject.additionalProperties) {
@@ -900,7 +842,5 @@ var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
 };
 
 exports.SchemaGenerator = SchemaGenerator;
-exports.isKeyword = isKeyword;
-exports.schemaKeywords = schemaKeywords;
-//# sourceMappingURL=chunk-7U6BHIOO.cjs.map
-//# sourceMappingURL=chunk-7U6BHIOO.cjs.map
+//# sourceMappingURL=chunk-WAB2O4DX.cjs.map
+//# sourceMappingURL=chunk-WAB2O4DX.cjs.map