@depup/openapi-typescript 7.13.0-depup.0

package/CONTRIBUTING.md

@@ -0,0 +1,149 @@
+# Contributing
+
+Thanks for being willing to contribute! 🙏
+
+**Working on your first Pull Request (PR)?** You can learn how from this free series [How to Contribute to an Open Source Project on GitHub](https://app.egghead.io/playlists/how-to-contribute-to-an-open-source-project-on-github).
+
+## Open issues
+
+Please check out the [the open issues](https://github.com/openapi-ts/openapi-typescript/issues). Issues labelled [**Good First Issue**](https://github.com/openapi-ts/openapi-typescript/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) are especially good to start with.
+
+Contributing doesn’t have to be in code. Simply answering questions in open issues or providing workarounds is as important as making pull requests.
+
+## Opening a Pull Request
+
+Pull requests are **welcome** for this repo!
+
+Bugfixes will always be accepted, though in some cases some small changes may be requested.
+
+However, if adding a feature or breaking change, please **open an issue first to discuss.** This ensures no time or work is wasted writing code that won’t be accepted to the project (see [Project Goals](https://openapi-ts.dev/about/#project-goals)). Undiscussed feature work may be rejected at the discretion of the maintainers.
+
+### Setup
+
+1. Install [pnpm](https://pnpm.io/)
+2. [Fork this repo](https://docs.github.com/en/get-started/quickstart/fork-a-repo) and clone your copy locally
+3. Run `pnpm i` to install dependencies
+
+### Writing code
+
+Create a new branch for your PR with `git checkout -b your-branch-name`. Add the relevant code as well as docs and tests. When you push everything up (`git push`), navigate back to your repo in GitHub and you should see a prompt to open a new PR.
+
+While best practices for commit messages are encouraged (e.g. start with an imperative verb, keep it short, use the body if needed), this repo doesn’t follow any specific guidelines. Clarity is favored over strict rules. Changelogs are generated separately from git (see [the Changelogs section](#changelogs))
+
+When working locally, run:
+
+```sh
+pnpm run dev
+```
+
+This will compile the code as you change automatically.
+
+#### Tip: use ASTExplorer.net!
+
+Working with the TypeScript AST can be daunting. Luckily, there’s [astexplorer.net](https://astexplorer.net) which makes it much more accessible. Rather than trying to build an AST from scratch (which is near impossible), instead:
+
+1. Switch to the **typescript** parser in the top menu
+2. Type out code in the left-hand panel
+3. Inspect the right-hand panel to see what the desired AST is.
+
+From there, you can refer to existing examples in the codebase. There may even be helper utilities in `src/lib/ts.ts` to make life easier.
+
+#### Tip: Use Test-driven Development!
+
+Contributing to this library is hard-bordering-on-impossible without a [test-driven development (TDD)](https://en.wikipedia.org/wiki/Test-driven_development) strategy. If you’re new to this, the basic workflow is:
+
+1. First, write a [test](#testing) that fully outlines what you’d _like_ the output to be.
+2. Next, make sure this test **fails** when you run `npm test` (yes, _fails!_)
+3. Then, make changes to `src/` until the tests pass.
+
+Reasoning about code generation can be quite difficult until you “invert your thinking” and approach it output-first. Adopting TDD can turn very unclear/abstract problems into concrete ones with clear steps to resolution.
+
+TL;DR: When starting any task, **write a failing test first!**
+
+#### Updating snapshot tests
+
+To add a schema as a snapshot test, modify the [/scripts/download-schemas.ts](/scripts/download-schemas.ts) script with a path to download. There are both single-file schemas as well as multi-file schemas.
+
+### Generating types
+
+It may be surprising to hear, but generating TypeScript types from OpenAPI is opinionated. Even though TypeScript and OpenAPI are close relatives—both JavaScript/JSON-based—they are nonetheless 2 different languages and thus there is room for interpretation. Further, some parts of the OpenAPI specification can be ambiguous on how they’re used, and what the expected type outcomes may be (though this is generally for more advanced use cases, such as specific implementations of `anyOf` as well as [discriminator](https://spec.openapis.org/oas/latest.html#discriminatorObject) and complex polymorphism).
+
+All that said, this library should strive to generate _the most predictable_ TypeScript output for a given schema. And to achieve that, it always helps to open an [issue](https://github.com/openapi-ts/openapi-typescript/issues) or [discussion](https://github.com/openapi-ts/openapi-typescript/discussions) to gather feedback.
+
+### Opening a PR
+
+When opening a pull request, make sure all of the following is done:
+
+- [x] Tests are added
+- [x] Build passes (`npm run build`)
+- [x] Tests pass (`npm test`)
+- [x] Linting passes (`npm run lint`)
+
+Lastly, be sure to fill out the complete PR template.
+
+### Changelogs
+
+The changelog is generated via [changesets](https://github.com/changesets/changesets), and is separate from Git commit messages and pull request titles. To write a human-readable changelog for your changes, run:
+
+```
+npx changeset
+```
+
+This will ask if it’s a `patch`, `minor`, or `major` change ([semver](https://semver.org/)), along with a plain description of what you did. Commit this new file along with the rest of your PR, and during the next release this will go into the official changelog!
+
+## Testing
+
+This library uses [Vitest](https://vitest.dev/) for testing. There’s a great [VS Code extension](https://marketplace.visualstudio.com/items?itemName=ZixuanChen.vitest-explorer) you can optionally use if you’d like in-editor debugging tools.
+
+### Running tests
+
+💡 The tests test **the production build** in `dist/`. Be sure to run `npm run build` before running tests (or keep `npm run dev` running in the background, which compiles as-you-work)!
+
+To run the entire test suite once, run:
+
+```sh
+pnpm test
+```
+
+To run an individual test:
+
+```sh
+pnpm test -- [partial filename]
+```
+
+To start the entire test suite in watch mode:
+
+```sh
+npx vitest
+```
+
+### Running linting
+
+Linting is handled via [Biome](https://biomejs.dev), a faster ESLint replacement. It was installed with `pnpm i` and can be run with:
+
+```sh
+pnpm run lint
+```
+
+### Updating snapshot examples
+
+⚠️ This may break tests if schemas have been updated
+
+```sh
+pnpm run update:examples
+```
+
+### Unit tests or snapshot tests?
+
+This library has both unit tests (tests that test a tiny part of a schema) and snapshot tests (tests that run over an entire, complete schema). When opening a PR, the former are more valuable than the latter, and are always required. However, updating snapshot tests can help with the following:
+
+- Fixing Node.js or OS-related bugs
+- Adding a CLI option that changes the entire output
+
+For most PRs, **snapshot tests can be avoided.** But for scenarios similar to the ones mentioned, they can ensure everything is working as expected.
+
+## Troubleshooting
+
+### When I run tests, it’s not picking up my changes
+
+Some tests import the **built package** and not the source file. Be sure to run `pnpm run build` to build the project. You can also run `pnpm run dev` as you work so changes are always up-to-date.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Drew Powers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @depup/openapi-typescript
+
+> Dependency-bumped version of [openapi-typescript](https://www.npmjs.com/package/openapi-typescript)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/openapi-typescript
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [openapi-typescript](https://www.npmjs.com/package/openapi-typescript) @ 7.13.0 |
+| Processed | 2026-03-22 |
+| Smoke test | failed |
+| Deps updated | 2 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @redocly/openapi-core | ^1.34.6 | ^2.24.1 |
+| yargs-parser | ^21.1.1 | ^22.0.0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/openapi-typescript
+
+License inherited from the original package.

package/bin/cli.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { createConfig, findConfig, loadConfig } from "@redocly/openapi-core";
+import parser from "yargs-parser";
+import openapiTS, { astToString, COMMENT_HEADER, c, error, formatTime, warn } from "../dist/index.mjs";
+
+const HELP = `Usage
+  $ openapi-typescript [input] [options]
+
+Options
+  --help                     Display this
+  --version                  Display the version
+  --redocly [path], -c       Specify path to Redocly config (default: redocly.yaml)
+  --output, -o               Specify output file (if not specified in redocly.yaml)
+  --enum                     Export true TS enums instead of unions
+  --enum-values              Export enum values as arrays
+  --conditional-enums        Only generate true TS enums when enum metadata is available (default: false)
+  --dedupe-enums             Dedupe enum types when \`--enum=true\` is set
+  --check                    Check that the generated types are up-to-date. (default: false)
+  --export-type, -t          Export top-level \`type\` instead of \`interface\`
+  --immutable                Generate readonly types
+  --additional-properties    Treat schema objects as if \`additionalProperties: true\` is set
+  --empty-objects-unknown    Generate \`unknown\` instead of \`Record<string, never>\` for empty objects
+  --default-non-nullable     Set to \`false\` to ignore default values when generating non-nullable types
+  --properties-required-by-default
+                             Treat schema objects as if \`required\` is set to all properties by default
+  --array-length             Generate tuples using array minItems / maxItems
+  --path-params-as-types     Convert paths to template literal types
+  --alphabetize              Sort object keys alphabetically
+  --exclude-deprecated       Exclude deprecated types
+  --root-types (optional)    Export schemas types at root level
+  --root-types-no-schema-prefix (optional)
+                             Do not add "Schema" prefix to types at the root level (should only be used with --root-types)
+  --root-types-keep-casing   Keep casing of root types (should only be used with --root-types)
+  --make-paths-enum          Generate ApiPaths enum for all paths
+  --read-write-markers       Generate $Read/$Write markers for readOnly/writeOnly properties
+`;
+
+const OUTPUT_FILE = "FILE";
+const OUTPUT_STDOUT = "STDOUT";
+const CWD = new URL(`file://${process.cwd()}/`);
+const REDOC_CONFIG_KEY = "x-openapi-ts";
+
+const timeStart = performance.now();
+
+const [, , ...args] = process.argv;
+if (args.includes("-ap")) {
+  errorAndExit(`The -ap alias has been deprecated. Use "--additional-properties" instead.`);
+}
+if (args.includes("--immutable-types")) {
+  errorAndExit(`The --immutable-types flag has been renamed to "--immutable".`);
+}
+if (args.includes("--support-array-length")) {
+  errorAndExit(`The --support-array-length flag has been renamed to "--array-length".`);
+}
+if (args.includes("-it")) {
+  errorAndExit(`The -it alias has been deprecated. Use "--immutable-types" instead.`);
+}
+if (args.includes("--redoc")) {
+  errorAndExit(`The --redoc config flag has been renamed to "--redocly" (or -c as shorthand).`);
+}
+if (args.includes("--root-types-no-schema-prefix") && !args.includes("--root-types")) {
+  // biome-ignore lint/suspicious/noConsole: this is a CLI
+  console.warn("--root-types-no-schema-prefix has no effect without --root-types flag");
+}
+if (args.includes("--root-types-keep-casing") && !args.includes("--root-types")) {
+  // biome-ignore lint/suspicious/noConsole: this is a CLI
+  console.warn("--root-types-keep-casing has no effect without --root-types flag");
+}
+
+const flags = parser(args, {
+  boolean: [
+    "additionalProperties",
+    "alphabetize",
+    "arrayLength",
+    "contentNever",
+    "defaultNonNullable",
+    "propertiesRequiredByDefault",
+    "emptyObjectsUnknown",
+    "enum",
+    "enumValues",
+    "conditionalEnums",
+    "dedupeEnums",
+    "check",
+    "excludeDeprecated",
+    "exportType",
+    "help",
+    "immutable",
+    "pathParamsAsTypes",
+    "rootTypes",
+    "rootTypesNoSchemaPrefix",
+    "rootTypesKeepCasing",
+    "makePathsEnum",
+    "generatePathParams",
+    "readWriteMarkers",
+  ],
+  string: ["output", "redocly"],
+  alias: {
+    redocly: ["c"],
+    exportType: ["t"],
+    output: ["o"],
+  },
+});
+
+/**
+ * Normalize the output path into a file URL.
+ * @param {string} output - The output path to be transformed.
+ * @returns {URL} The transformed file URL.
+ */
+function normalizeOutput(output) {
+  if (path.isAbsolute(output)) {
+    return new URL(`file://${output}`);
+  }
+  return new URL(output, CWD);
+}
+
+/**
+ * Check if the generated types are up-to-date.
+ * @param {string} current - The current generated types.
+ * @param {URL} outputPath - The path to the output file.
+ */
+function checkStaleOutput(current, outputPath) {
+  if (flags.check) {
+    const previous = fs.readFileSync(outputPath, "utf8");
+    if (current === previous) {
+      process.exit(0);
+    } else {
+      error("Generated types are not up-to-date!");
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * @param {string | URL} schema
+ * @param {@type import('@redocly/openapi-core').Config} redocly
+ */
+async function generateSchema(schema, { redocly, silent = false }) {
+  return `${COMMENT_HEADER}${astToString(
+    await openapiTS(schema, {
+      additionalProperties: flags.additionalProperties,
+      alphabetize: flags.alphabetize,
+      arrayLength: flags.arrayLength,
+      contentNever: flags.contentNever,
+      propertiesRequiredByDefault: flags.propertiesRequiredByDefault,
+      defaultNonNullable: flags.defaultNonNullable,
+      emptyObjectsUnknown: flags.emptyObjectsUnknown,
+      enum: flags.enum,
+      enumValues: flags.enumValues,
+      conditionalEnums: flags.conditionalEnums,
+      dedupeEnums: flags.dedupeEnums,
+      excludeDeprecated: flags.excludeDeprecated,
+      exportType: flags.exportType,
+      immutable: flags.immutable,
+      pathParamsAsTypes: flags.pathParamsAsTypes,
+      rootTypes: flags.rootTypes,
+      rootTypesNoSchemaPrefix: flags.rootTypesNoSchemaPrefix,
+      rootTypesKeepCasing: flags.rootTypesKeepCasing,
+      makePathsEnum: flags.makePathsEnum,
+      generatePathParams: flags.generatePathParams,
+      readWriteMarkers: flags.readWriteMarkers,
+      redocly,
+      silent,
+    }),
+  )}`;
+}
+
+/** pretty-format error message but also throw */
+function errorAndExit(message) {
+  error(message);
+  throw new Error(message);
+}
+
+function done(input, output, time) {
+  // final console output
+  // biome-ignore lint/suspicious/noConsole: this is a CLI
+  console.log(`🚀 ${c.green(`${input} → ${c.bold(output)}`)} ${c.dim(`[${formatTime(time)}]`)}`);
+}
+
+function findRedocConfigPath() {
+  if (!flags.redocly) {
+    return findConfig();
+  }
+  const explicitPath = path.resolve(flags.redocly);
+  if (!fs.existsSync(explicitPath)) {
+    return undefined;
+  }
+  const stat = fs.statSync(explicitPath);
+  return stat.isDirectory() ? findConfig(explicitPath) : explicitPath;
+}
+
+async function main() {
+  if ("help" in flags) {
+    // biome-ignore lint/suspicious/noConsole: this is a CLI
+    console.info(HELP);
+    process.exit(0);
+  }
+  const packageJSON = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+  if ("version" in flags) {
+    // biome-ignore lint/suspicious/noConsole: this is a CLI
+    console.info(`v${packageJSON.version}`);
+    process.exit(0);
+  }
+
+  const outputType = flags.output ? OUTPUT_FILE : OUTPUT_STDOUT; // FILE or STDOU
+  if (outputType !== OUTPUT_STDOUT) {
+    // biome-ignore lint/suspicious/noConsole: this is a CLI
+    console.info(`✨ ${c.bold(`openapi-typescript ${packageJSON.version}`)}`);
+  }
+
+  const input = flags._[0];
+
+  const redocConfigPath = findRedocConfigPath();
+  if (flags.redocly && !redocConfigPath) {
+    errorAndExit(`Redocly config not found at: ${flags.redocly}`);
+  }
+  const redocly = redocConfigPath
+    ? await loadConfig({ configPath: redocConfigPath })
+    : await createConfig({}, { extends: ["minimal"] });
+
+  // handle Redoc APIs
+  const hasRedoclyApis = Object.keys(redocly?.apis ?? {}).length > 0;
+  if (hasRedoclyApis) {
+    if (input) {
+      warn("APIs are specified both in Redocly Config and CLI argument. Only using Redocly config.");
+    }
+    await Promise.all(
+      Object.entries(redocly.apis).map(async ([name, api]) => {
+        let configRoot = CWD;
+        if (redocly.configFile) {
+          // note: this will be absolute if --redoc is passed; otherwise, relative
+          configRoot = path.isAbsolute(redocly.configFile)
+            ? new URL(`file://${redocly.configFile}`)
+            : new URL(redocly.configFile, `file://${process.cwd()}/`);
+        }
+        if (!api[REDOC_CONFIG_KEY]?.output) {
+          errorAndExit(
+            `API ${name} is missing an \`${REDOC_CONFIG_KEY}.output\` key. See https://openapi-ts.dev/cli/#multiple-schemas.`,
+          );
+        }
+        const result = await generateSchema(new URL(api.root, configRoot), { redocly });
+        const outFile = new URL(api[REDOC_CONFIG_KEY].output, configRoot);
+        checkStaleOutput(result, outFile);
+        fs.mkdirSync(new URL(".", outFile), { recursive: true });
+        fs.writeFileSync(outFile, result, "utf8");
+        done(name, api[REDOC_CONFIG_KEY].output, performance.now() - timeStart);
+      }),
+    );
+  }
+
+  // handle stdin
+  else if (!input) {
+    const result = await generateSchema(process.stdin, {
+      redocly,
+      silent: outputType === OUTPUT_STDOUT,
+    });
+    if (outputType === OUTPUT_STDOUT) {
+      // if stdout, (still) don’t log anything to console!
+      process.stdout.write(result);
+    } else {
+      const outFile = normalizeOutput(flags.output);
+      checkStaleOutput(result, outFile);
+      fs.mkdirSync(new URL(".", outFile), { recursive: true });
+      fs.writeFileSync(outFile, result, "utf8");
+      done("stdin", flags.output, performance.now() - timeStart);
+    }
+  }
+
+  // handle single file
+  else {
+    // throw error on glob
+    if (input.includes("*")) {
+      errorAndExit(
+        "Globbing has been deprecated in favor of redocly.yaml’s `apis` keys. See https://openapi-ts.dev/cli/#multiple-schemas",
+      );
+    }
+    const result = await generateSchema(new URL(input, CWD), {
+      redocly,
+      silent: outputType === OUTPUT_STDOUT,
+    });
+    if (outputType === OUTPUT_STDOUT) {
+      // if stdout, (still) don’t log anything to console!
+      process.stdout.write(result);
+    } else {
+      const outFile = normalizeOutput(flags.output);
+      checkStaleOutput(result, outFile);
+      fs.mkdirSync(new URL(".", outFile), { recursive: true });
+      fs.writeFileSync(outFile, result, "utf8");
+      done(input, flags.output, performance.now() - timeStart);
+    }
+  }
+}
+
+main();

package/changes.json

@@ -0,0 +1,14 @@
+{
+  "bumped": {
+    "@redocly/openapi-core": {
+      "from": "^1.34.6",
+      "to": "^2.24.1"
+    },
+    "yargs-parser": {
+      "from": "^21.1.1",
+      "to": "^22.0.0"
+    }
+  },
+  "timestamp": "2026-03-22T00:40:14.254Z",
+  "totalUpdated": 2
+}

package/dist/index.cjs

@@ -0,0 +1,152 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const node_perf_hooks = require('node:perf_hooks');
+const openapiCore = require('@redocly/openapi-core');
+const redoc = require('./lib/redoc.cjs');
+const utils = require('./lib/utils.cjs');
+const index = require('./transform/index.cjs');
+const ts = require('./lib/ts.cjs');
+const componentsObject = require('./transform/components-object.cjs');
+const headerObject = require('./transform/header-object.cjs');
+const mediaTypeObject = require('./transform/media-type-object.cjs');
+const operationObject = require('./transform/operation-object.cjs');
+const parameterObject = require('./transform/parameter-object.cjs');
+const pathItemObject = require('./transform/path-item-object.cjs');
+const pathsObject = require('./transform/paths-object.cjs');
+const requestBodyObject = require('./transform/request-body-object.cjs');
+const responseObject = require('./transform/response-object.cjs');
+const responsesObject = require('./transform/responses-object.cjs');
+const schemaObject = require('./transform/schema-object.cjs');
+const c = require('ansi-colors');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const c__default = /*#__PURE__*/_interopDefaultCompat(c);
+
+const COMMENT_HEADER = `/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+`;
+async function openapiTS(source, options = {}) {
+  if (!source) {
+    throw new Error("Empty schema. Please specify a URL, file path, or Redocly Config");
+  }
+  const redoc$1 = options.redocly ?? await openapiCore.createConfig(
+    {
+      rules: {
+        "operation-operationId-unique": { severity: "error" }
+        // throw error on duplicate operationIDs
+      }
+    },
+    { extends: ["minimal"] }
+  );
+  const schema = await redoc.validateAndBundle(source, {
+    redoc: redoc$1,
+    cwd: options.cwd instanceof URL ? options.cwd : new URL(`file://${options.cwd ?? process.cwd()}/`),
+    silent: options.silent ?? false
+  });
+  const ctx = {
+    additionalProperties: options.additionalProperties ?? false,
+    alphabetize: options.alphabetize ?? false,
+    arrayLength: options.arrayLength ?? false,
+    defaultNonNullable: options.defaultNonNullable ?? true,
+    discriminators: utils.scanDiscriminators(schema, options),
+    emptyObjectsUnknown: options.emptyObjectsUnknown ?? false,
+    enum: options.enum ?? false,
+    enumValues: options.enumValues ?? false,
+    conditionalEnums: options.conditionalEnums ?? false,
+    dedupeEnums: options.dedupeEnums ?? false,
+    excludeDeprecated: options.excludeDeprecated ?? false,
+    exportType: options.exportType ?? false,
+    immutable: options.immutable ?? false,
+    rootTypes: options.rootTypes ?? false,
+    rootTypesNoSchemaPrefix: options.rootTypesNoSchemaPrefix ?? false,
+    rootTypesKeepCasing: options.rootTypesKeepCasing ?? false,
+    injectFooter: [],
+    pathParamsAsTypes: options.pathParamsAsTypes ?? false,
+    postTransform: typeof options.postTransform === "function" ? options.postTransform : void 0,
+    propertiesRequiredByDefault: options.propertiesRequiredByDefault ?? false,
+    redoc: redoc$1,
+    silent: options.silent ?? false,
+    inject: options.inject ?? void 0,
+    transform: typeof options.transform === "function" ? options.transform : void 0,
+    transformProperty: typeof options.transformProperty === "function" ? options.transformProperty : void 0,
+    makePathsEnum: options.makePathsEnum ?? false,
+    generatePathParams: options.generatePathParams ?? false,
+    readWriteMarkers: options.readWriteMarkers ?? false,
+    resolve($ref) {
+      return utils.resolveRef(schema, $ref, { silent: options.silent ?? false });
+    }
+  };
+  const transformT = node_perf_hooks.performance.now();
+  const result = index(schema, ctx);
+  utils.debug("Completed AST transformation for entire document", "ts", node_perf_hooks.performance.now() - transformT);
+  return result;
+}
+
+exports.createDiscriminatorProperty = utils.createDiscriminatorProperty;
+exports.createRef = utils.createRef;
+exports.debug = utils.debug;
+exports.error = utils.error;
+exports.formatTime = utils.formatTime;
+exports.getEntries = utils.getEntries;
+exports.resolveRef = utils.resolveRef;
+exports.scanDiscriminators = utils.scanDiscriminators;
+exports.walk = utils.walk;
+exports.warn = utils.warn;
+exports.transformSchema = index;
+exports.BOOLEAN = ts.BOOLEAN;
+exports.FALSE = ts.FALSE;
+exports.JS_ENUM_INVALID_CHARS_RE = ts.JS_ENUM_INVALID_CHARS_RE;
+exports.JS_PROPERTY_INDEX_INVALID_CHARS_RE = ts.JS_PROPERTY_INDEX_INVALID_CHARS_RE;
+exports.JS_PROPERTY_INDEX_RE = ts.JS_PROPERTY_INDEX_RE;
+exports.NEVER = ts.NEVER;
+exports.NULL = ts.NULL;
+exports.NUMBER = ts.NUMBER;
+exports.QUESTION_TOKEN = ts.QUESTION_TOKEN;
+exports.SPECIAL_CHARACTER_MAP = ts.SPECIAL_CHARACTER_MAP;
+exports.STRING = ts.STRING;
+exports.TRUE = ts.TRUE;
+exports.UNDEFINED = ts.UNDEFINED;
+exports.UNKNOWN = ts.UNKNOWN;
+exports.addJSDocComment = ts.addJSDocComment;
+exports.astToString = ts.astToString;
+exports.enumCache = ts.enumCache;
+exports.oapiRef = ts.oapiRef;
+exports.stringToAST = ts.stringToAST;
+exports.tsArrayLiteralExpression = ts.tsArrayLiteralExpression;
+exports.tsDedupe = ts.tsDedupe;
+exports.tsEnum = ts.tsEnum;
+exports.tsEnumMember = ts.tsEnumMember;
+exports.tsIntersection = ts.tsIntersection;
+exports.tsIsPrimitive = ts.tsIsPrimitive;
+exports.tsLiteral = ts.tsLiteral;
+exports.tsModifiers = ts.tsModifiers;
+exports.tsNullable = ts.tsNullable;
+exports.tsOmit = ts.tsOmit;
+exports.tsPropertyIndex = ts.tsPropertyIndex;
+exports.tsReadonlyArray = ts.tsReadonlyArray;
+exports.tsRecord = ts.tsRecord;
+exports.tsUnion = ts.tsUnion;
+exports.tsWithRequired = ts.tsWithRequired;
+exports.transformComponentsObject = componentsObject.default;
+exports.transformHeaderObject = headerObject;
+exports.transformMediaTypeObject = mediaTypeObject;
+exports.injectOperationObject = operationObject.injectOperationObject;
+exports.transformOperationObject = operationObject.default;
+exports.transformParameterObject = parameterObject;
+exports.transformPathItemObject = pathItemObject;
+exports.transformPathsObject = pathsObject;
+exports.transformRequestBodyObject = requestBodyObject;
+exports.transformResponseObject = responseObject;
+exports.transformResponsesObject = responsesObject;
+exports.transformSchemaObject = schemaObject.default;
+exports.transformSchemaObjectWithComposition = schemaObject.transformSchemaObjectWithComposition;
+exports.c = c__default;
+exports.COMMENT_HEADER = COMMENT_HEADER;
+exports.default = openapiTS;
+//# sourceMappingURL=index.cjs.map