@kubb/plugin-oas 0.0.0-canary-20240509211223

package/dist/index.cjs

@@ -0,0 +1,985 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkECXSQTMVcjs = require('./chunk-ECXSQTMV.cjs');
+
+
+
+var _chunkVNFSHGSNcjs = require('./chunk-VNFSHGSN.cjs');
+
+
+
+
+
+
+var _chunk55NUFNT6cjs = require('./chunk-55NUFNT6.cjs');
+
+// src/index.ts
+_chunk55NUFNT6cjs.init_cjs_shims.call(void 0, );
+
+// src/plugin.ts
+_chunk55NUFNT6cjs.init_cjs_shims.call(void 0, );
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _core = require('@kubb/core');
+var _transformers = require('@kubb/core/transformers'); var _transformers2 = _interopRequireDefault(_transformers);
+var pluginOasName = "plugin-oas";
+var pluginOas = _core.createPlugin.call(void 0, (options) => {
+  const {
+    output = { path: "schemas", export: false },
+    experimentalFilter: filter,
+    experimentalSort: sort,
+    validate = true,
+    serverIndex = 0,
+    contentType
+  } = options;
+  const getOas = async ({ config, logger, formatOptions }) => {
+    try {
+      const oas = await _chunkECXSQTMVcjs.parseFromConfig.call(void 0, config, formatOptions);
+      if (validate) {
+        await oas.valdiate();
+      }
+      return oas;
+    } catch (e) {
+      const error = e;
+      logger.emit("warning", _optionalChain([error, 'optionalAccess', _ => _.message]));
+      return _chunkECXSQTMVcjs.parseFromConfig.call(void 0, config);
+    }
+  };
+  return {
+    name: pluginOasName,
+    options,
+    api() {
+      const { config, logger } = this;
+      return {
+        getOas(formatOptions) {
+          return getOas({ config, logger, formatOptions });
+        },
+        async getSchemas({ includes } = {}) {
+          const oas = await this.getOas();
+          return _chunkECXSQTMVcjs.getSchemas.call(void 0, { oas, contentType, includes });
+        },
+        async getBaseURL() {
+          const oasInstance = await this.getOas();
+          const baseURL = _optionalChain([oasInstance, 'access', _2 => _2.api, 'access', _3 => _3.servers, 'optionalAccess', _4 => _4.at, 'call', _5 => _5(serverIndex), 'optionalAccess', _6 => _6.url]);
+          return baseURL;
+        },
+        contentType
+      };
+    },
+    resolvePath(baseName) {
+      if (output === false) {
+        return void 0;
+      }
+      const root = _path2.default.resolve(this.config.root, this.config.output.path);
+      return _path2.default.resolve(root, output.path, baseName);
+    },
+    resolveName(name, type) {
+      return _transformers.camelCase.call(void 0, name, { isFile: type === "file" });
+    },
+    async writeFile(source, writePath) {
+      if (!writePath.endsWith(".json") || !source) {
+        return;
+      }
+      return this.fileManager.write(source, writePath, { sanity: false });
+    },
+    async buildStart() {
+      if (!output) {
+        return;
+      }
+      const oas = await getOas({
+        config: this.config,
+        logger: this.logger,
+        formatOptions: {
+          filterSet: filter,
+          sortSet: sort
+        }
+      });
+      await oas.dereference();
+      const schemas = _chunkECXSQTMVcjs.getSchemas.call(void 0, { oas, contentType });
+      const mapSchema = async ([name, schema]) => {
+        const resolvedPath = this.resolvePath({
+          baseName: `${name}.json`,
+          pluginKey: this.plugin.key
+        });
+        const resvoledFileName = this.resolveName({
+          name: `${name}.json`,
+          pluginKey: [pluginOasName],
+          type: "file"
+        });
+        if (!resolvedPath) {
+          return;
+        }
+        await this.addFile({
+          path: resolvedPath,
+          baseName: resvoledFileName,
+          source: JSON.stringify(schema),
+          meta: {
+            pluginKey: this.plugin.key
+          }
+        });
+      };
+      const promises = Object.entries(schemas).map(mapSchema);
+      await Promise.all(promises);
+    }
+  };
+});
+
+// src/OperationGenerator.ts
+_chunk55NUFNT6cjs.init_cjs_shims.call(void 0, );
+
+
+var _operationsByMethod, _getOptions, getOptions_fn, _isExcluded, isExcluded_fn, _isIncluded, isIncluded_fn, _methods, methods_get;
+var OperationGenerator = class extends _core.Generator {
+  constructor() {
+    super(...arguments);
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _getOptions);
+    /**
+     *
+     * @deprecated
+     */
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _isExcluded);
+    /**
+     *
+     * @deprecated
+     */
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _isIncluded);
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _methods);
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _operationsByMethod, {});
+  }
+  get operationsByMethod() {
+    return _chunk55NUFNT6cjs.__privateGet.call(void 0, this, _operationsByMethod);
+  }
+  set operationsByMethod(paths) {
+    _chunk55NUFNT6cjs.__privateSet.call(void 0, this, _operationsByMethod, paths);
+  }
+  getSchemas(operation, forStatusCode) {
+    const pathParamsSchema = this.context.oas.getParametersSchema(operation, "path");
+    const queryParamsSchema = this.context.oas.getParametersSchema(operation, "query");
+    const headerParamsSchema = this.context.oas.getParametersSchema(operation, "header");
+    const requestSchema = this.context.oas.getRequestSchema(operation);
+    const responseStatusCode = forStatusCode || operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith("2")) || 200;
+    const responseSchema = this.context.oas.getResponseSchema(operation, responseStatusCode);
+    const statusCodes = operation.getResponseStatusCodes().map((statusCode) => {
+      let name = statusCode;
+      if (name === "default") {
+        name = "error";
+      }
+      const schema = this.context.oas.getResponseSchema(operation, statusCode);
+      return {
+        name: _transformers2.default.pascalCase(`${operation.getOperationId()} ${name}`),
+        description: _optionalChain([operation, 'access', _7 => _7.getResponseByStatusCode, 'call', _8 => _8(statusCode), 'optionalAccess', _9 => _9.description]),
+        schema,
+        operation,
+        operationName: _transformers2.default.pascalCase(`${operation.getOperationId()}`),
+        statusCode: name === "error" ? void 0 : Number(statusCode),
+        keys: _optionalChain([schema, 'optionalAccess', _10 => _10.properties]) ? Object.keys(schema.properties) : void 0
+      };
+    });
+    return {
+      pathParams: pathParamsSchema ? {
+        name: _transformers2.default.pascalCase(`${operation.getOperationId()} PathParams`),
+        operation,
+        operationName: _transformers2.default.pascalCase(`${operation.getOperationId()}`),
+        schema: pathParamsSchema,
+        keys: pathParamsSchema.properties ? Object.keys(pathParamsSchema.properties) : void 0
+      } : void 0,
+      queryParams: queryParamsSchema ? {
+        name: _transformers2.default.pascalCase(`${operation.getOperationId()} QueryParams`),
+        operation,
+        operationName: _transformers2.default.pascalCase(`${operation.getOperationId()}`),
+        schema: queryParamsSchema,
+        keys: queryParamsSchema.properties ? Object.keys(queryParamsSchema.properties) : []
+      } : void 0,
+      headerParams: headerParamsSchema ? {
+        name: _transformers2.default.pascalCase(`${operation.getOperationId()} HeaderParams`),
+        operation,
+        operationName: _transformers2.default.pascalCase(`${operation.getOperationId()}`),
+        schema: headerParamsSchema,
+        keys: headerParamsSchema.properties ? Object.keys(headerParamsSchema.properties) : void 0
+      } : void 0,
+      request: requestSchema ? {
+        name: _transformers2.default.pascalCase(`${operation.getOperationId()} ${operation.method === "get" ? "queryRequest" : "mutationRequest"}`),
+        description: _optionalChain([operation, 'access', _11 => _11.schema, 'access', _12 => _12.requestBody, 'optionalAccess', _13 => _13.description]),
+        operation,
+        operationName: _transformers2.default.pascalCase(`${operation.getOperationId()}`),
+        schema: requestSchema,
+        keys: requestSchema.properties ? Object.keys(requestSchema.properties) : void 0,
+        keysToOmit: requestSchema.properties ? Object.keys(requestSchema.properties).filter((key) => {
+          const item = _optionalChain([requestSchema, 'access', _14 => _14.properties, 'optionalAccess', _15 => _15[key]]);
+          return _optionalChain([item, 'optionalAccess', _16 => _16.readOnly]);
+        }) : void 0
+      } : void 0,
+      response: {
+        name: _transformers2.default.pascalCase(`${operation.getOperationId()} ${operation.method === "get" ? "queryResponse" : "mutationResponse"}`),
+        description: _optionalChain([operation, 'access', _17 => _17.getResponseAsJSONSchema, 'call', _18 => _18(responseStatusCode), 'optionalAccess', _19 => _19.at, 'call', _20 => _20(0), 'optionalAccess', _21 => _21.description]),
+        operation,
+        operationName: _transformers2.default.pascalCase(`${operation.getOperationId()}`),
+        schema: responseSchema,
+        statusCode: Number(responseStatusCode),
+        keys: _optionalChain([responseSchema, 'optionalAccess', _22 => _22.properties]) ? Object.keys(responseSchema.properties) : void 0,
+        keysToOmit: _optionalChain([responseSchema, 'optionalAccess', _23 => _23.properties]) ? Object.keys(responseSchema.properties).filter((key) => {
+          const item = _optionalChain([responseSchema, 'access', _24 => _24.properties, 'optionalAccess', _25 => _25[key]]);
+          return _optionalChain([item, 'optionalAccess', _26 => _26.writeOnly]);
+        }) : void 0
+      },
+      errors: statusCodes.filter((item) => _optionalChain([item, 'access', _27 => _27.statusCode, 'optionalAccess', _28 => _28.toString, 'call', _29 => _29(), 'access', _30 => _30.startsWith, 'call', _31 => _31("4")]) || _optionalChain([item, 'access', _32 => _32.statusCode, 'optionalAccess', _33 => _33.toString, 'call', _34 => _34(), 'access', _35 => _35.startsWith, 'call', _36 => _36("5")])),
+      statusCodes
+    };
+  }
+  async build() {
+    const { oas } = this.context;
+    const paths = oas.getPaths();
+    this.operationsByMethod = Object.entries(paths).reduce((acc, [path2, method]) => {
+      const methods = Object.keys(method);
+      methods.forEach((method2) => {
+        const operation = oas.operation(path2, method2);
+        if (operation && _chunk55NUFNT6cjs.__privateGet.call(void 0, this, _methods, methods_get)[method2]) {
+          const isExcluded = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _isExcluded, isExcluded_fn).call(this, operation, method2);
+          const isIncluded = this.context.include ? _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _isIncluded, isIncluded_fn).call(this, operation, method2) : true;
+          if (isIncluded && !isExcluded) {
+            if (!acc[path2]) {
+              acc[path2] = {};
+            }
+            acc[path2] = {
+              ...acc[path2],
+              [method2]: {
+                operation,
+                schemas: this.getSchemas(operation)
+              }
+            };
+          }
+        }
+      });
+      return acc;
+    }, {});
+    const promises = Object.keys(this.operationsByMethod).reduce((acc, path2) => {
+      const methods = this.operationsByMethod[path2] ? Object.keys(this.operationsByMethod[path2]) : [];
+      methods.forEach((method) => {
+        const { operation } = _optionalChain([this, 'access', _37 => _37.operationsByMethod, 'access', _38 => _38[path2], 'optionalAccess', _39 => _39[method]]);
+        const options = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getOptions, getOptions_fn).call(this, operation, method);
+        const promiseMethod = _optionalChain([_chunk55NUFNT6cjs.__privateGet.call(void 0, this, _methods, methods_get), 'access', _40 => _40[method], 'optionalAccess', _41 => _41.call, 'call', _42 => _42(this, operation, {
+          ...this.options,
+          ...options
+        })]);
+        const promiseOperation = this.operation.call(this, operation, {
+          ...this.options,
+          ...options
+        });
+        if (promiseMethod) {
+          acc.push(promiseMethod);
+        }
+        if (promiseOperation) {
+          acc.push(promiseOperation);
+        }
+      });
+      return acc;
+    }, []);
+    const operations = Object.values(this.operationsByMethod).map((item) => Object.values(item).map((item2) => item2.operation));
+    promises.push(this.all(operations.flat().filter(Boolean), this.operationsByMethod));
+    const files = await Promise.all(promises);
+    return files.flat().filter(Boolean);
+  }
+};
+_operationsByMethod = new WeakMap();
+_getOptions = new WeakSet();
+getOptions_fn = function(operation, method) {
+  const { override = [] } = this.context;
+  return _optionalChain([override, 'access', _43 => _43.find, 'call', _44 => _44(({ pattern, type }) => {
+    if (type === "tag") {
+      return !!_optionalChain([operation, 'access', _45 => _45.getTags, 'call', _46 => _46(), 'access', _47 => _47[0], 'optionalAccess', _48 => _48.name, 'access', _49 => _49.match, 'call', _50 => _50(pattern)]);
+    }
+    if (type === "operationId") {
+      return !!operation.getOperationId().match(pattern);
+    }
+    if (type === "path") {
+      return !!operation.path.match(pattern);
+    }
+    if (type === "method") {
+      return !!method.match(pattern);
+    }
+    return false;
+  }), 'optionalAccess', _51 => _51.options]) || {};
+};
+_isExcluded = new WeakSet();
+isExcluded_fn = function(operation, method) {
+  const { exclude = [] } = this.context;
+  let matched = false;
+  exclude.forEach(({ pattern, type }) => {
+    if (type === "tag" && !matched) {
+      matched = !!_optionalChain([operation, 'access', _52 => _52.getTags, 'call', _53 => _53(), 'access', _54 => _54[0], 'optionalAccess', _55 => _55.name, 'access', _56 => _56.match, 'call', _57 => _57(pattern)]);
+    }
+    if (type === "operationId" && !matched) {
+      matched = !!operation.getOperationId().match(pattern);
+    }
+    if (type === "path" && !matched) {
+      matched = !!operation.path.match(pattern);
+    }
+    if (type === "method" && !matched) {
+      matched = !!method.match(pattern);
+    }
+  });
+  return matched;
+};
+_isIncluded = new WeakSet();
+isIncluded_fn = function(operation, method) {
+  const { include = [] } = this.context;
+  let matched = false;
+  include.forEach(({ pattern, type }) => {
+    if (type === "tag" && !matched) {
+      matched = !!_optionalChain([operation, 'access', _58 => _58.getTags, 'call', _59 => _59(), 'access', _60 => _60[0], 'optionalAccess', _61 => _61.name, 'access', _62 => _62.match, 'call', _63 => _63(pattern)]);
+    }
+    if (type === "operationId" && !matched) {
+      matched = !!operation.getOperationId().match(pattern);
+    }
+    if (type === "path" && !matched) {
+      matched = !!operation.path.match(pattern);
+    }
+    if (type === "method" && !matched) {
+      matched = !!method.match(pattern);
+    }
+  });
+  return matched;
+};
+_methods = new WeakSet();
+methods_get = function() {
+  return {
+    get: this.get,
+    post: this.post,
+    patch: this.patch,
+    put: this.put,
+    delete: this.delete,
+    head: void 0,
+    options: void 0,
+    trace: void 0
+  };
+};
+
+// src/SchemaGenerator.ts
+_chunk55NUFNT6cjs.init_cjs_shims.call(void 0, );
+
+
+var _utils = require('@kubb/core/utils');
+var _oas = require('@kubb/oas');
+var _remeda = require('remeda');
+var _usedAliasNames, _getUsedEnumNames, getUsedEnumNames_fn, _getOptions2, getOptions_fn2, _getUnknownReturn, getUnknownReturn_fn, _parseProperties, parseProperties_fn, _getRefAlias, getRefAlias_fn, _getParsedSchemaObject, getParsedSchemaObject_fn, _parseSchemaObject, parseSchemaObject_fn;
+var _SchemaGenerator = class _SchemaGenerator extends _core.Generator {
+  constructor() {
+    super(...arguments);
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _getUsedEnumNames);
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _getOptions2);
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _getUnknownReturn);
+    /**
+     * Recursively creates a type literal with the given props.
+     */
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _parseProperties);
+    /**
+     * Create a type alias for the schema referenced by the given ReferenceObject
+     */
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _getRefAlias);
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _getParsedSchemaObject);
+    /**
+     * This is the very core of the OpenAPI to TS conversion - it takes a
+     * schema and returns the appropriate type.
+     */
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _parseSchemaObject);
+    // Collect the types of all referenced schemas, so we can export them later
+    this.refs = {};
+    // Keep track of already used type aliases
+    _chunk55NUFNT6cjs.__privateAdd.call(void 0, this, _usedAliasNames, {});
+  }
+  /**
+   * Creates a type node from a given schema.
+   * Delegates to getBaseTypeFromSchema internally and
+   * optionally adds a union with null.
+   */
+  buildSchemas(props) {
+    const options = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getOptions2, getOptions_fn2).call(this, props);
+    const defaultSchemas = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _parseSchemaObject, parseSchemaObject_fn).call(this, props);
+    const schemas = _optionalChain([options, 'access', _64 => _64.transformers, 'optionalAccess', _65 => _65.schema, 'optionalCall', _66 => _66(props, defaultSchemas)]) || defaultSchemas || [];
+    return _remeda.uniqueWith.call(void 0, schemas, _remeda.isDeepEqual);
+  }
+  deepSearch(schemas, keyword) {
+    return _SchemaGenerator.deepSearch(schemas, keyword);
+  }
+  find(schemas, keyword) {
+    return _SchemaGenerator.find(schemas, keyword);
+  }
+  static deepSearch(schemas, keyword) {
+    const foundItems = [];
+    _optionalChain([schemas, 'optionalAccess', _67 => _67.forEach, 'call', _68 => _68((schema) => {
+      if (schema.keyword === keyword) {
+        foundItems.push(schema);
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.object) {
+        const subItem = schema;
+        Object.values(_optionalChain([subItem, 'access', _69 => _69.args, 'optionalAccess', _70 => _70.properties]) || {}).forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch(entrySchema, keyword));
+        });
+        Object.values(_optionalChain([subItem, 'access', _71 => _71.args, 'optionalAccess', _72 => _72.additionalProperties]) || {}).forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.array) {
+        const subItem = schema;
+        subItem.args.items.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.and) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.tuple) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.union) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+    })]);
+    return foundItems;
+  }
+  static findInObject(schemas, keyword) {
+    let foundItem = void 0;
+    _optionalChain([schemas, 'optionalAccess', _73 => _73.forEach, 'call', _74 => _74((schema) => {
+      if (!foundItem && schema.keyword === keyword) {
+        foundItem = schema;
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.object) {
+        const subItem = schema;
+        Object.values(_optionalChain([subItem, 'access', _75 => _75.args, 'optionalAccess', _76 => _76.properties]) || {}).forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find(entrySchema, keyword);
+          }
+        });
+        Object.values(_optionalChain([subItem, 'access', _77 => _77.args, 'optionalAccess', _78 => _78.additionalProperties]) || {}).forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+    })]);
+    return foundItem;
+  }
+  static find(schemas, keyword) {
+    let foundItem = void 0;
+    _optionalChain([schemas, 'optionalAccess', _79 => _79.forEach, 'call', _80 => _80((schema) => {
+      if (!foundItem && schema.keyword === keyword) {
+        foundItem = schema;
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.array) {
+        const subItem = schema;
+        subItem.args.items.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.and) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.tuple) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+      if (schema.keyword === _chunkVNFSHGSNcjs.schemaKeywords.union) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+    })]);
+    return foundItem;
+  }
+  async build() {
+    const { oas, contentType, include } = this.context;
+    const schemas = _chunkECXSQTMVcjs.getSchemas.call(void 0, { oas, contentType, includes: include });
+    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
+      const promiseOperation = this.schema.call(this, name, schema);
+      if (promiseOperation) {
+        acc.push(promiseOperation);
+      }
+      return acc;
+    }, []);
+    const files = await Promise.all(promises);
+    return files.flat().filter(Boolean);
+  }
+};
+_usedAliasNames = new WeakMap();
+_getUsedEnumNames = new WeakSet();
+getUsedEnumNames_fn = function(props) {
+  const options = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getOptions2, getOptions_fn2).call(this, props);
+  return options.usedEnumNames || {};
+};
+_getOptions2 = new WeakSet();
+getOptions_fn2 = function({ name }) {
+  const { override = [] } = this.context;
+  return {
+    ...this.options,
+    ..._optionalChain([override, 'access', _81 => _81.find, 'call', _82 => _82(({ pattern, type }) => {
+      if (name && type === "schemaName") {
+        return !!name.match(pattern);
+      }
+      return false;
+    }), 'optionalAccess', _83 => _83.options]) || {}
+  };
+};
+_getUnknownReturn = new WeakSet();
+getUnknownReturn_fn = function(props) {
+  const options = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getOptions2, getOptions_fn2).call(this, props);
+  if (options.unknownType === "any") {
+    return _chunkVNFSHGSNcjs.schemaKeywords.any;
+  }
+  return _chunkVNFSHGSNcjs.schemaKeywords.unknown;
+};
+_parseProperties = new WeakSet();
+parseProperties_fn = function({ schema, name }) {
+  const properties = _optionalChain([schema, 'optionalAccess', _84 => _84.properties]) || {};
+  const additionalProperties = _optionalChain([schema, 'optionalAccess', _85 => _85.additionalProperties]);
+  const required = _optionalChain([schema, 'optionalAccess', _86 => _86.required]);
+  const propertiesSchemas = Object.keys(properties).map((propertyName) => {
+    const validationFunctions = [];
+    const propertySchema = properties[propertyName];
+    const isRequired = Array.isArray(required) ? _optionalChain([required, 'optionalAccess', _87 => _87.includes, 'call', _88 => _88(propertyName)]) : !!required;
+    const nullable = _nullishCoalesce(_nullishCoalesce(propertySchema.nullable, () => ( propertySchema["x-nullable"])), () => ( false));
+    validationFunctions.push(...this.buildSchemas({ schema: propertySchema, name: propertyName, parentName: name }));
+    validationFunctions.push({
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.name,
+      args: propertyName
+    });
+    if (!isRequired && nullable) {
+      validationFunctions.push({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.nullish });
+    } else if (!isRequired) {
+      validationFunctions.push({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.optional });
+    }
+    return {
+      [propertyName]: validationFunctions
+    };
+  }).reduce((acc, curr) => ({ ...acc, ...curr }), {});
+  let additionalPropertiesSchemas = [];
+  if (additionalProperties) {
+    additionalPropertiesSchemas = additionalProperties === true ? [{ keyword: _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getUnknownReturn, getUnknownReturn_fn).call(this, { schema, name }) }] : this.buildSchemas({ schema: additionalProperties, parentName: name });
+  }
+  return [
+    {
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.object,
+      args: {
+        properties: propertiesSchemas,
+        additionalProperties: additionalPropertiesSchemas
+      }
+    }
+  ];
+};
+_getRefAlias = new WeakSet();
+getRefAlias_fn = function(obj) {
+  const { $ref } = obj;
+  let ref = this.refs[$ref];
+  const originalName = _utils.getUniqueName.call(void 0, $ref.replace(/.+\//, ""), _chunk55NUFNT6cjs.__privateGet.call(void 0, this, _usedAliasNames));
+  const propertyName = this.context.pluginManager.resolveName({
+    name: originalName,
+    pluginKey: this.context.plugin.key,
+    type: "function"
+  });
+  if (ref) {
+    return [
+      {
+        keyword: _chunkVNFSHGSNcjs.schemaKeywords.ref,
+        args: { name: ref.propertyName, path: ref.path }
+      }
+    ];
+  }
+  const fileName = this.context.pluginManager.resolveName({
+    name: originalName,
+    pluginKey: this.context.plugin.key,
+    type: "file"
+  });
+  const file = this.context.pluginManager.getFile({
+    name: fileName,
+    pluginKey: this.context.plugin.key,
+    extName: ".ts"
+  });
+  ref = this.refs[$ref] = {
+    propertyName,
+    originalName,
+    path: file.path
+  };
+  return [
+    {
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.ref,
+      args: { name: ref.propertyName, path: _optionalChain([ref, 'optionalAccess', _89 => _89.path]), isTypeOnly: false }
+    }
+  ];
+};
+_getParsedSchemaObject = new WeakSet();
+getParsedSchemaObject_fn = function(schema) {
+  const parsedSchema = _chunkECXSQTMVcjs.getSchemaFactory.call(void 0, this.context.oas)(schema);
+  return parsedSchema;
+};
+_parseSchemaObject = new WeakSet();
+parseSchemaObject_fn = function({ schema: _schema, name, parentName }) {
+  const options = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getOptions2, getOptions_fn2).call(this, { schema: _schema, name });
+  const unknownReturn = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getUnknownReturn, getUnknownReturn_fn).call(this, { schema: _schema, name });
+  const { schema, version } = _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getParsedSchemaObject, getParsedSchemaObject_fn).call(this, _schema);
+  const resolvedName = this.context.pluginManager.resolveName({
+    name: `${parentName || ""} ${name}`,
+    pluginKey: this.context.plugin.key,
+    type: "type"
+  });
+  if (!schema) {
+    return [{ keyword: unknownReturn }];
+  }
+  const baseItems = [
+    {
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.schema,
+      args: {
+        type: schema.type,
+        format: schema.format
+      }
+    }
+  ];
+  const min = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
+  const max = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.maximum, () => ( schema.maxLength)), () => ( schema.maxItems)), () => ( void 0));
+  const nullable = _nullishCoalesce(_nullishCoalesce(schema.nullable, () => ( schema["x-nullable"])), () => ( false));
+  if (schema.default !== void 0 && !Array.isArray(schema.default)) {
+    if (typeof schema.default === "string") {
+      baseItems.push({
+        keyword: _chunkVNFSHGSNcjs.schemaKeywords.default,
+        args: _transformers2.default.stringify(schema.default)
+      });
+    }
+    if (typeof schema.default === "boolean") {
+      baseItems.push({
+        keyword: _chunkVNFSHGSNcjs.schemaKeywords.default,
+        args: _nullishCoalesce(schema.default, () => ( false))
+      });
+    }
+  }
+  if (schema.description) {
+    baseItems.push({
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.describe,
+      args: schema.description
+    });
+  }
+  if (schema.pattern) {
+    baseItems.unshift({
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.matches,
+      args: schema.pattern
+    });
+  }
+  if (max !== void 0) {
+    baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.max, args: max });
+  }
+  if (min !== void 0) {
+    baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.min, args: min });
+  }
+  if (nullable) {
+    baseItems.push({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.nullable });
+  }
+  if (schema.type && Array.isArray(schema.type)) {
+    const [_schema2, nullable2] = schema.type;
+    if (nullable2 === "null") {
+      baseItems.push({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.nullable });
+    }
+  }
+  if (schema.readOnly) {
+    baseItems.push({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.readOnly });
+  }
+  if (_oas.isReference.call(void 0, schema)) {
+    return [..._chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getRefAlias, getRefAlias_fn).call(this, schema), ...baseItems];
+  }
+  if (schema.oneOf) {
+    const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+    const union = {
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.union,
+      args: schema.oneOf.map((item) => {
+        return item && this.buildSchemas({ schema: item, name, parentName })[0];
+      }).filter(Boolean).filter((item) => {
+        return item && item.keyword !== unknownReturn;
+      })
+    };
+    if (schemaWithoutOneOf.properties) {
+      return [...this.buildSchemas({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems];
+    }
+    return [union, ...baseItems];
+  }
+  if (schema.anyOf) {
+    const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
+    const union = {
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.union,
+      args: schema.anyOf.map((item) => {
+        return item && this.buildSchemas({ schema: item, name, parentName })[0];
+      }).filter(Boolean).filter((item) => {
+        return item && item.keyword !== unknownReturn;
+      }).map((item) => {
+        if (_chunkVNFSHGSNcjs.isKeyword.call(void 0, item, _chunkVNFSHGSNcjs.schemaKeywords.object)) {
+          return {
+            ...item,
+            args: {
+              ...item.args,
+              strict: true
+            }
+          };
+        }
+        return item;
+      })
+    };
+    if (schemaWithoutAnyOf.properties) {
+      return [...this.buildSchemas({ schema: schemaWithoutAnyOf, name, parentName }), union, ...baseItems];
+    }
+    return [union, ...baseItems];
+  }
+  if (schema.allOf) {
+    const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+    const and = {
+      keyword: _chunkVNFSHGSNcjs.schemaKeywords.and,
+      args: schema.allOf.map((item) => {
+        return item && this.buildSchemas({ schema: item, name, parentName })[0];
+      }).filter(Boolean).filter((item) => {
+        return item && item.keyword !== unknownReturn;
+      })
+    };
+    if (schemaWithoutAllOf.properties) {
+      return [
+        {
+          ...and,
+          args: [...and.args || [], ...this.buildSchemas({ schema: schemaWithoutAllOf, name, parentName })]
+        },
+        ...baseItems
+      ];
+    }
+    return [and, ...baseItems];
+  }
+  if (schema.enum) {
+    const enumName = _utils.getUniqueName.call(void 0, _transformers.pascalCase.call(void 0, [parentName, name, options.enumSuffix].join(" ")), _chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _getUsedEnumNames, getUsedEnumNames_fn).call(this, { schema, name }));
+    const typeName = this.context.pluginManager.resolveName({
+      name: enumName,
+      pluginKey: this.context.plugin.key,
+      type: "type"
+    });
+    const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schema).map((extensionKey) => {
+      return [
+        {
+          keyword: _chunkVNFSHGSNcjs.schemaKeywords.enum,
+          args: {
+            name,
+            typeName,
+            asConst: false,
+            items: [...new Set(schema[extensionKey])].map((name2, index) => ({
+              name: _transformers2.default.stringify(name2),
+              value: _optionalChain([schema, 'access', _90 => _90.enum, 'optionalAccess', _91 => _91[index]]),
+              format: _remeda.isNumber.call(void 0, _optionalChain([schema, 'access', _92 => _92.enum, 'optionalAccess', _93 => _93[index]])) ? "number" : "string"
+            }))
+          }
+        },
+        ...baseItems.filter(
+          (item) => item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.min && item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.max && item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.matches
+        )
+      ];
+    });
+    if (schema.type === "number" || schema.type === "integer") {
+      const enumNames = _optionalChain([extensionEnums, 'access', _94 => _94[0], 'optionalAccess', _95 => _95.find, 'call', _96 => _96((item) => _chunkVNFSHGSNcjs.isKeyword.call(void 0, item, _chunkVNFSHGSNcjs.schemaKeywords.enum))]);
+      return [
+        {
+          keyword: _chunkVNFSHGSNcjs.schemaKeywords.enum,
+          args: {
+            name: enumName,
+            typeName,
+            asConst: true,
+            items: _optionalChain([enumNames, 'optionalAccess', _97 => _97.args, 'optionalAccess', _98 => _98.items]) ? [...new Set(enumNames.args.items)].map(({ name: name2, value }) => ({
+              name: name2,
+              value,
+              format: "number"
+            })) : [...new Set(schema.enum)].map((value) => {
+              return {
+                name: value,
+                value,
+                format: "number"
+              };
+            })
+          }
+        },
+        ...baseItems.filter((item) => item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.min && item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.max && item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.matches)
+      ];
+    }
+    if (extensionEnums.length > 0 && extensionEnums[0]) {
+      return extensionEnums[0];
+    }
+    return [
+      {
+        keyword: _chunkVNFSHGSNcjs.schemaKeywords.enum,
+        args: {
+          name: enumName,
+          typeName,
+          asConst: false,
+          items: [...new Set(schema.enum)].map((value) => ({
+            name: _transformers2.default.stringify(value),
+            value,
+            format: _remeda.isNumber.call(void 0, value) ? "number" : "string"
+          }))
+        }
+      },
+      ...baseItems.filter((item) => item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.min && item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.max && item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.matches)
+    ];
+  }
+  if ("prefixItems" in schema) {
+    const prefixItems = schema.prefixItems;
+    return [
+      {
+        keyword: _chunkVNFSHGSNcjs.schemaKeywords.tuple,
+        args: prefixItems.map((item) => {
+          return this.buildSchemas({ schema: item, name, parentName })[0];
+        }).filter(Boolean)
+      },
+      ...baseItems
+    ];
+  }
+  if (version === "3.1" && "const" in schema) {
+    if (schema["const"]) {
+      return [
+        {
+          keyword: _chunkVNFSHGSNcjs.schemaKeywords.const,
+          args: {
+            name: schema["const"],
+            format: typeof schema["const"] === "number" ? "number" : "string",
+            value: schema["const"]
+          }
+        },
+        ...baseItems
+      ];
+    }
+    return [{ keyword: _chunkVNFSHGSNcjs.schemaKeywords.null }];
+  }
+  if (schema.format) {
+    switch (schema.format) {
+      case "binary":
+        baseItems.push({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.blob });
+        return baseItems;
+      case "date-time":
+        if (options.dateType) {
+          if (options.dateType === "date") {
+            baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.date, args: { type: "date" } });
+            return baseItems;
+          }
+          if (options.dateType === "stringOffset") {
+            baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.datetime, args: { offset: true } });
+            return baseItems;
+          }
+          if (options.dateType === "stringLocal") {
+            baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.datetime, args: { local: true } });
+            return baseItems;
+          }
+          baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.datetime, args: { offset: false } });
+          return baseItems;
+        }
+        break;
+      case "date":
+        if (options.dateType) {
+          if (options.dateType === "date") {
+            baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.date, args: { type: "date" } });
+            return baseItems;
+          }
+          baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.date, args: { type: "string" } });
+          return baseItems;
+        }
+        break;
+      case "time":
+        if (options.dateType) {
+          if (options.dateType === "date") {
+            baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.time, args: { type: "date" } });
+            return baseItems;
+          }
+          baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.time, args: { type: "string" } });
+          return baseItems;
+        }
+        break;
+      case "uuid":
+        baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.uuid });
+        break;
+      case "email":
+      case "idn-email":
+        baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.email });
+        break;
+      case "uri":
+      case "ipv4":
+      case "ipv6":
+      case "uri-reference":
+      case "hostname":
+      case "idn-hostname":
+        baseItems.unshift({ keyword: _chunkVNFSHGSNcjs.schemaKeywords.url });
+        break;
+      default:
+        break;
+    }
+  }
+  if ("items" in schema || schema.type === "array") {
+    const min2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
+    const max2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.maximum, () => ( schema.maxLength)), () => ( schema.maxItems)), () => ( void 0));
+    const items = this.buildSchemas({ schema: "items" in schema ? schema.items : [], name, parentName });
+    return [
+      {
+        keyword: _chunkVNFSHGSNcjs.schemaKeywords.array,
+        args: {
+          items,
+          min: min2,
+          max: max2
+        }
+      },
+      ...baseItems.filter((item) => item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.min && item.keyword !== _chunkVNFSHGSNcjs.schemaKeywords.max)
+    ];
+  }
+  if (schema.properties || schema.additionalProperties) {
+    return [..._chunk55NUFNT6cjs.__privateMethod.call(void 0, this, _parseProperties, parseProperties_fn).call(this, { schema, name }), ...baseItems];
+  }
+  if (schema.type) {
+    if (Array.isArray(schema.type)) {
+      const [type] = schema.type;
+      return [
+        ...this.buildSchemas({
+          schema: {
+            ...schema,
+            type
+          },
+          name,
+          parentName
+        }),
+        ...baseItems
+      ].filter(Boolean);
+    }
+    return [{ keyword: schema.type }, ...baseItems];
+  }
+  return [{ keyword: unknownReturn }];
+};
+var SchemaGenerator = _SchemaGenerator;
+
+// src/index.ts
+var definePluginDefault = pluginOas;
+var src_default = definePluginDefault;
+
+
+
+
+
+
+
+
+exports.OperationGenerator = OperationGenerator; exports.SchemaGenerator = SchemaGenerator; exports.default = src_default; exports.isKeyword = _chunkVNFSHGSNcjs.isKeyword; exports.pluginOas = pluginOas; exports.pluginOasName = pluginOasName; exports.schemaKeywords = _chunkVNFSHGSNcjs.schemaKeywords;
+//# sourceMappingURL=index.cjs.map