diff --git a/.changeset/shaggy-impalas-develop.md b/.changeset/shaggy-impalas-develop.md
new file mode 100644
index 000000000..21e238f23
--- /dev/null
+++ b/.changeset/shaggy-impalas-develop.md
@@ -0,0 +1,5 @@
+---
+"openapi-typescript": major
+---
+
+Export enumValues as const arrays. Derive schema types from literal values.
diff --git a/.github/ISSUE_TEMPLATE/01_openapi-typescript-bug.yml b/.github/ISSUE_TEMPLATE/01_openapi-typescript-bug.yml
index 3dfa26f92..620772127 100644
--- a/.github/ISSUE_TEMPLATE/01_openapi-typescript-bug.yml
+++ b/.github/ISSUE_TEMPLATE/01_openapi-typescript-bug.yml
@@ -6,18 +6,21 @@ labels:
   - triage
 body:
   - type: input
+    id: version
     attributes:
       label: openapi-typescript version
       placeholder: x.x.x
     validations:
       required: true
   - type: input
+    id: node
     attributes:
       label: Node.js version
       placeholder: 20.x.x
     validations:
       required: true
   - type: input
+    id: os
     attributes:
       label: OS + version
       placeholder: macOS 15.1.1
@@ -45,14 +48,14 @@ body:
       required: true
   - type: checkboxes
     id: required
-    label: Required
     attributes:
+      label: Required
       options:
         - label: My OpenAPI schema is valid and passes the [Redocly validator](https://redocly.com/docs/cli/commands/lint/) (`npx @redocly/cli@latest lint`)
           required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-typescript/CONTRIBUTING.md))
diff --git a/.github/ISSUE_TEMPLATE/01_openapi-typescript-feat.yml b/.github/ISSUE_TEMPLATE/01_openapi-typescript-feat.yml
index 28fdf9344..0461ea317 100644
--- a/.github/ISSUE_TEMPLATE/01_openapi-typescript-feat.yml
+++ b/.github/ISSUE_TEMPLATE/01_openapi-typescript-feat.yml
@@ -1,9 +1,10 @@
 name: "openapi-typescript: Feature request"
 description: Propose new functionality or a breaking change
-title: ""
 labels:
   - openapi-ts
   - enhancement
+projects:
+  - openapi-ts/2
 body:
   - type: textarea
     id: description
@@ -21,7 +22,7 @@ body:
       required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-typescript/CONTRIBUTING.md))
diff --git a/.github/ISSUE_TEMPLATE/02_openapi-fetch-bug.yml b/.github/ISSUE_TEMPLATE/02_openapi-fetch-bug.yml
index f53726675..0cf42230b 100644
--- a/.github/ISSUE_TEMPLATE/02_openapi-fetch-bug.yml
+++ b/.github/ISSUE_TEMPLATE/02_openapi-fetch-bug.yml
@@ -6,8 +6,9 @@ labels:
   - triage
 body:
   - type: input
+    id: version
     attributes:
-      label: Version
+      label: openapi-fetch version
       placeholder: x.x.x
     validations:
       required: true
@@ -33,7 +34,7 @@ body:
       required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-fetch/CONTRIBUTING.md))
diff --git a/.github/ISSUE_TEMPLATE/02_openapi-fetch-feat.yml b/.github/ISSUE_TEMPLATE/02_openapi-fetch-feat.yml
index 241269a0b..829e340bc 100644
--- a/.github/ISSUE_TEMPLATE/02_openapi-fetch-feat.yml
+++ b/.github/ISSUE_TEMPLATE/02_openapi-fetch-feat.yml
@@ -1,9 +1,10 @@
 name: "openapi-fetch: Feature request"
 description: Propose new functionality or a breaking change
-title: ""
 labels:
   - openapi-fetch
   - enhancement
+projects:
+  - openapi-ts/3
 body:
   - type: textarea
     id: description
@@ -21,7 +22,7 @@ body:
       required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-fetch/CONTRIBUTING.md))
diff --git a/.github/ISSUE_TEMPLATE/03_openapi-react-query-bug.yml b/.github/ISSUE_TEMPLATE/03_openapi-react-query-bug.yml
index 563c33b2e..378293bf8 100644
--- a/.github/ISSUE_TEMPLATE/03_openapi-react-query-bug.yml
+++ b/.github/ISSUE_TEMPLATE/03_openapi-react-query-bug.yml
@@ -6,8 +6,9 @@ labels:
   - triage
 body:
   - type: input
+    id: version
     attributes:
-      label: Version
+      label: openapi-react-query version
       placeholder: x.x.x
     validations:
       required: true
@@ -26,6 +27,7 @@ body:
     validations:
       required: true
   - type: textarea
+    id: expected
     attributes:
       label: Expected result
       description: (In case it’s not obvious)
@@ -33,7 +35,7 @@ body:
       required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-react-query/CONTRIBUTING.md))
diff --git a/.github/ISSUE_TEMPLATE/03_openapi-react-query-feat.yml b/.github/ISSUE_TEMPLATE/03_openapi-react-query-feat.yml
index c20560c1e..f2b8d4f1d 100644
--- a/.github/ISSUE_TEMPLATE/03_openapi-react-query-feat.yml
+++ b/.github/ISSUE_TEMPLATE/03_openapi-react-query-feat.yml
@@ -1,6 +1,5 @@
 name: "openapi-react-query: Feature request"
 description: Propose new functionality or a breaking change
-title: ""
 labels:
   - openapi-react-query
   - enhancement
@@ -21,7 +20,7 @@ body:
       required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-react-query/CONTRIBUTING.md))
diff --git a/.github/ISSUE_TEMPLATE/04_swr-openapi-bug.yml b/.github/ISSUE_TEMPLATE/04_swr-openapi-bug.yml
index 63cb36f05..6feba784f 100644
--- a/.github/ISSUE_TEMPLATE/04_swr-openapi-bug.yml
+++ b/.github/ISSUE_TEMPLATE/04_swr-openapi-bug.yml
@@ -5,8 +5,9 @@ labels:
   - bug
 body:
   - type: input
+    id: version
     attributes:
-      label: Version
+      label: swr-openapi version
       placeholder: x.x.x
     validations:
       required: true
@@ -25,6 +26,7 @@ body:
     validations:
       required: true
   - type: textarea
+    id: expected
     attributes:
       label: Expected result
       description: (In case it’s not obvious)
@@ -32,7 +34,7 @@ body:
       required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/swr-openapi/CONTRIBUTING.md))
diff --git a/.github/ISSUE_TEMPLATE/04_swr-openapi-feat.yml b/.github/ISSUE_TEMPLATE/04_swr-openapi-feat.yml
index 56da4825b..bc9c564b3 100644
--- a/.github/ISSUE_TEMPLATE/04_swr-openapi-feat.yml
+++ b/.github/ISSUE_TEMPLATE/04_swr-openapi-feat.yml
@@ -1,6 +1,5 @@
 name: "swr-openapi: Feature request"
 description: Propose new functionality or a breaking change
-title: ""
 labels:
   - swr-openapi
   - enhancement
@@ -21,7 +20,7 @@ body:
       required: true
   - type: checkboxes
     id: extra
-    label: Extra
     attributes:
+      label: Extra
       options:
         - label: I’m willing to open a PR (see [CONTRIBUTING.md](https://github.com/openapi-ts/openapi-typescript/blob/main/packages/swr-openapi/CONTRIBUTING.md))
diff --git a/docs/.vitepress/config.ts b/docs/.vitepress/config.ts
index 8556147d0..55da861e9 100644
--- a/docs/.vitepress/config.ts
+++ b/docs/.vitepress/config.ts
@@ -4,7 +4,7 @@ import zh from "./zh";
 import ja from "./ja";
 import shared from "./shared";
 import { transformerTwoslash } from "@shikijs/vitepress-twoslash";
-import { ModuleKind, ModuleResolutionKind } from "typescript";
+import { ModuleResolutionKind } from "typescript";
 
 // https://vitepress.dev/reference/site-config
 export default defineConfig({
diff --git a/docs/.vitepress/en.ts b/docs/.vitepress/en.ts
index e7471111b..a15fe27cb 100644
--- a/docs/.vitepress/en.ts
+++ b/docs/.vitepress/en.ts
@@ -139,7 +139,7 @@ export default defineConfig({
     ],
     footer: {
       message:
-        'Released under the <a href="https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-typescript/LICENSE">MIT License</a>.',
+        'Released under the <a href="https://github.com/openapi-ts/openapi-typescript/blob/main/packages/openapi-typescript/LICENSE">MIT License</a>. Powered by <a href="https://netlify.com">Netlify</a>.',
     },
   },
 });
diff --git a/docs/.vitepress/shared.ts b/docs/.vitepress/shared.ts
index d531543f4..7b575d66e 100644
--- a/docs/.vitepress/shared.ts
+++ b/docs/.vitepress/shared.ts
@@ -26,7 +26,7 @@ const shared: UserConfig = {
   themeConfig: {
     siteTitle: false,
     logo: "/assets/openapi-ts.svg",
-    outline: 'deep',
+    outline: "deep",
     search: {
       provider: "algolia",
       options: {
diff --git a/docs/.vitepress/theme/CustomLayout.vue b/docs/.vitepress/theme/CustomLayout.vue
index 0a71a2955..6fd09798d 100644
--- a/docs/.vitepress/theme/CustomLayout.vue
+++ b/docs/.vitepress/theme/CustomLayout.vue
@@ -39,7 +39,7 @@ const { Layout } = DefaultTheme;
       </a></template
     >
 
-    <!-- Silver sponsor logos -->
+    <!-- Sidebar sponsors -->
     <template #sidebar-nav-after>
       <div class="sidenav-sponsors">
         <h5>Gold Sponsors</h5>
@@ -58,6 +58,9 @@ const { Layout } = DefaultTheme;
             </a>
           </li>
         </ul>
+        <p class="sidebar-hosting">
+          Powered by <a href="https://netlify.com">Netlify</a>
+        </p>
       </div>
     </template>
   </Layout>
@@ -147,6 +150,25 @@ const { Layout } = DefaultTheme;
   height: 3rem;
   width: auto;
 }
+
+.sidebar-hosting {
+  color: var(--vp-c-text-3);
+  font-size: 0.75rem;
+  font-weight: 500;
+  letter-spacing: 0.0625em;
+  margin-block-start: 2rem;
+  text-transform: uppercase;
+
+  a {
+    color: var(--vp-c-brand-1);
+    text-decoration: underline;
+
+    &:hover,
+    &:focus-visible {
+      color: var(--vp-c-brand-2);
+    }
+  }
+}
 </style>
 
 <style>
diff --git a/docs/6.x/node.md b/docs/6.x/node.md
index 54394d740..9a5909aaa 100644
--- a/docs/6.x/node.md
+++ b/docs/6.x/node.md
@@ -122,6 +122,16 @@ Resultant diff with correctly-typed `file` property:
 +    file?: Blob;
 ```
 
-Any [Schema Object](https://spec.openapis.org/oas/latest.html#schema-object) present in your schema will be run through this formatter (even remote ones!). Also be sure to check the `metadata` parameter for additional context that may be helpful.
+#### transform / postTransform metadata
 
-There are many other uses for this besides checking `format`. Because this must return a **string** you can produce any arbitrary TypeScript code you’d like (even your own custom types).
+Any [Schema Object](https://spec.openapis.org/oas/latest.html#schema-object) present in your schema will be run through `transform`, prior to its conversion to a TypeScript AST node, and `postTransform` after its conversion, including remote schemas!
+
+The `metadata` parameter present on both `transform` and `postTransform` has additional context that may be helpful.
+
+| Property | Description |
+|-|-|
+| `metadata.path` | A [`$ref`](https://json-schema.org/understanding-json-schema/structuring#dollarref) URI string, pointing to the current schema object |
+| `metadata.schema` | The schema object being transformed (only present for `postTransform`) |
+| `metadata.ctx` | The GlobalContext object, containing
+
+There are many other uses for this besides checking `format`. Because `tranform` may return a **string** you can produce any arbitrary TypeScript code you’d like (even your own custom types).
diff --git a/docs/scripts/update-contributors.js b/docs/scripts/update-contributors.js
index f93d43a6a..1f1351933 100644
--- a/docs/scripts/update-contributors.js
+++ b/docs/scripts/update-contributors.js
@@ -7,11 +7,14 @@ const data = JSON.parse(fs.readFileSync(CONTRIBUTORS_JSON, "utf8"));
 
 const ONE_WEEK = 1000 * 60 * 60 * 24;
 
-const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
-if (!GITHUB_TOKEN) {
-  throw new Error(
-    'GITHUB_TOKEN not set! Create a token with "read:user" scope and set as an environment variable.\nhttps://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-personal-access-token-classic',
-  );
+function getGitHubToken() {
+  const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+  if (!GITHUB_TOKEN) {
+    throw new Error(
+      'GITHUB_TOKEN not set! Create a token with "read:user" scope and set as an environment variable.\nhttps://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-personal-access-token-classic',
+    );
+  }
+  return GITHUB_TOKEN;
 }
 
 class UserFetchError extends Error {
@@ -37,7 +40,7 @@ async function fetchUserInfo(username) {
   const res = await fetch(`https://api.github.com/users/${username}`, {
     headers: {
       Accept: "application/vnd.github+json",
-      Authorization: `Bearer ${GITHUB_TOKEN}`,
+      Authorization: `Bearer ${getGitHubToken()}`,
       "X-GitHub-Api-Version": "2022-11-28",
     },
   });
@@ -189,19 +192,14 @@ const CONTRIBUTORS = {
 
 async function main() {
   let i = 0;
-  const total = Object.values(CONTRIBUTORS).reduce(
-    (total, next) => total + next.size,
-    0,
-  );
+  const total = Object.values(CONTRIBUTORS).reduce((total, next) => total + next.size, 0);
   await Promise.all(
     Object.entries(CONTRIBUTORS).map(async ([repo, contributors]) => {
       data[repo] ??= [];
       for (const username of [...contributors]) {
         i++;
         // skip profiles that have been updated within the past week
-        const { lastFetch } = data[repo].find(
-          (u) => u.username === username,
-        ) ?? { lastFetch: 0 };
+        const { lastFetch } = data[repo].find((u) => u.username === username) ?? { lastFetch: 0 };
         if (Date.now() - lastFetch < ONE_WEEK) {
           // biome-ignore lint/suspicious/noConsoleLog: this is a script
           console.log(`[${i}/${total}] (Skipped ${username})`);
@@ -219,10 +217,7 @@ async function main() {
           upsert(data[repo], userData);
           // biome-ignore lint/suspicious/noConsoleLog: this is a script
           console.log(`[${i}/${total}] Updated for ${username}`);
-          fs.writeFileSync(
-            new URL("../data/contributors.json", import.meta.url),
-            JSON.stringify(data),
-          ); // update file while fetching (sync happens safely in between fetches)
+          fs.writeFileSync(new URL("../data/contributors.json", import.meta.url), JSON.stringify(data)); // update file while fetching (sync happens safely in between fetches)
         } catch (err) {
           if (err instanceof UserFetchError && err.notFound) {
             console.warn(`[${i}/${total}] (Skipped ${username}, not found)`);
diff --git a/packages/openapi-typescript/CHANGELOG.md b/packages/openapi-typescript/CHANGELOG.md
index 6c14deec9..427b41dca 100644
--- a/packages/openapi-typescript/CHANGELOG.md
+++ b/packages/openapi-typescript/CHANGELOG.md
@@ -1,5 +1,11 @@
 # openapi-typescript
 
+## 7.5.1
+
+### Patch Changes
+
+- [#2049](https://github.com/openapi-ts/openapi-typescript/pull/2049) [`39f9b2f`](https://github.com/openapi-ts/openapi-typescript/commit/39f9b2fb913eb13817592b22f1bbe35de1bc4c33) Thanks [@duncanbeevers](https://github.com/duncanbeevers)! - Add schema to postTransform options
+
 ## 7.5.0
 
 ### Minor Changes
diff --git a/packages/openapi-typescript/examples/digital-ocean-api.ts b/packages/openapi-typescript/examples/digital-ocean-api.ts
index 85f6ac19a..230e398f7 100644
--- a/packages/openapi-typescript/examples/digital-ocean-api.ts
+++ b/packages/openapi-typescript/examples/digital-ocean-api.ts
@@ -3,6 +3,9 @@
  * Do not make direct changes to the file.
  */
 
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
 export interface paths {
     "/v2/1-clicks": {
         parameters: {
@@ -28798,6 +28801,3 @@ export interface operations {
         };
     };
 }
-type WithRequired<T, K extends keyof T> = T & {
-    [P in K]-?: T[P];
-};
diff --git a/packages/openapi-typescript/src/index.ts b/packages/openapi-typescript/src/index.ts
index f1b739496..a71957273 100644
--- a/packages/openapi-typescript/src/index.ts
+++ b/packages/openapi-typescript/src/index.ts
@@ -81,7 +81,7 @@ export default async function openapiTS(
     immutable: options.immutable ?? false,
     rootTypes: options.rootTypes ?? false,
     rootTypesNoSchemaPrefix: options.rootTypesNoSchemaPrefix ?? false,
-    injectFooter: [],
+    injectNodes: [],
     pathParamsAsTypes: options.pathParamsAsTypes ?? false,
     postTransform: typeof options.postTransform === "function" ? options.postTransform : undefined,
     propertiesRequiredByDefault: options.propertiesRequiredByDefault ?? false,
diff --git a/packages/openapi-typescript/src/lib/ts.ts b/packages/openapi-typescript/src/lib/ts.ts
index 3f795c60c..1d3258410 100644
--- a/packages/openapi-typescript/src/lib/ts.ts
+++ b/packages/openapi-typescript/src/lib/ts.ts
@@ -209,12 +209,14 @@ export function tsDedupe(types: ts.TypeNode[]): ts.TypeNode[] {
 }
 
 export const enumCache = new Map<string, ts.EnumDeclaration>();
+export const constEnumCache = new Map<string, ts.VariableStatement>();
+export type EnumMemberMetadata = { readonly name?: string; readonly description?: string };
 
 /** Create a TS enum (with sanitized name and members) */
 export function tsEnum(
   name: string,
   members: (string | number)[],
-  metadata?: { name?: string; description?: string }[],
+  metadata?: EnumMemberMetadata[],
   options?: { export?: boolean; shouldCache?: boolean },
 ) {
   let enumName = sanitizeMemberName(name);
@@ -224,69 +226,87 @@ export function tsEnum(
     key = `${members
       .slice(0)
       .sort()
-      .map((v, i) => {
-        return `${metadata?.[i]?.name ?? String(v)}:${metadata?.[i]?.description || ""}`;
+      .map((v, index) => {
+        return `${metadata?.[index]?.name ?? String(v)}:${metadata?.[index]?.description || ""}`;
       })
       .join(",")}`;
-    if (enumCache.has(key)) {
-      return enumCache.get(key) as ts.EnumDeclaration;
+
+    const cached = enumCache.get(key);
+    if (cached) {
+      return cached;
     }
   }
   const enumDeclaration = ts.factory.createEnumDeclaration(
     /* modifiers */ options ? tsModifiers({ export: options.export ?? false }) : undefined,
     /* name      */ enumName,
-    /* members   */ members.map((value, i) => tsEnumMember(value, metadata?.[i])),
+    /* members   */ members.map((value, index) => tsEnumMember(value, metadata?.[index])),
   );
   options?.shouldCache && enumCache.set(key, enumDeclaration);
   return enumDeclaration;
 }
 
-/** Create an exported TS array literal expression  */
+/** Create a TS array literal expression */
 export function tsArrayLiteralExpression(
   name: string,
-  elementType: ts.TypeNode,
-  values: (string | number)[],
-  options?: { export?: boolean; readonly?: boolean; injectFooter?: ts.Node[] },
+  elementType: ts.TypeNode | undefined,
+  members: (string | number)[],
+  metadata?: readonly EnumMemberMetadata[],
+  options?: { export?: boolean; readonly?: boolean; inject?: ts.Node[]; shouldCache?: boolean },
 ) {
-  let variableName = sanitizeMemberName(name);
-  variableName = `${variableName[0].toLowerCase()}${variableName.substring(1)}`;
+  let key = "";
+  if (options?.shouldCache) {
+    key = `${members
+      .slice(0)
+      .sort()
+      .map((v, i) => {
+        return `${metadata?.[i]?.name ?? String(v)}:${metadata?.[i]?.description || ""}`;
+      })
+      .join(",")}`;
+    const cached = constEnumCache.get(key);
+    if (cached) {
+      return cached;
+    }
+  }
+
+  const variableName = sanitizeMemberName(name);
+
+  const arrayType =
+    (elementType && options?.readonly ? tsReadonlyArray(elementType, options.inject) : undefined) ??
+    (elementType && !options?.readonly ? ts.factory.createArrayTypeNode(elementType) : undefined);
+
+  const initializer = ts.factory.createArrayLiteralExpression(
+    members.flatMap((value, index) => {
+      return tsLiteralValue(value, metadata?.[index]) ?? [];
+    }),
+  );
 
-  const arrayType = options?.readonly
-    ? tsReadonlyArray(elementType, options.injectFooter)
-    : ts.factory.createArrayTypeNode(elementType);
+  const asConstInitializer = arrayType
+    ? initializer
+    : ts.factory.createAsExpression(initializer, ts.factory.createTypeReferenceNode("const"));
 
-  return ts.factory.createVariableStatement(
+  const variableStatement = ts.factory.createVariableStatement(
     options ? tsModifiers({ export: options.export ?? false }) : undefined,
     ts.factory.createVariableDeclarationList(
       [
         ts.factory.createVariableDeclaration(
-          variableName,
-          undefined,
-          arrayType,
-          ts.factory.createArrayLiteralExpression(
-            values.map((value) => {
-              if (typeof value === "number") {
-                if (value < 0) {
-                  return ts.factory.createPrefixUnaryExpression(
-                    ts.SyntaxKind.MinusToken,
-                    ts.factory.createNumericLiteral(Math.abs(value)),
-                  );
-                } else {
-                  return ts.factory.createNumericLiteral(value);
-                }
-              } else {
-                return ts.factory.createStringLiteral(value);
-              }
-            }),
-          ),
+          /* name             */ variableName,
+          /* exclamationToken */ undefined,
+          /* type             */ arrayType,
+          /* initializer      */ asConstInitializer,
         ),
       ],
       ts.NodeFlags.Const,
     ),
   );
+
+  if (options?.shouldCache) {
+    constEnumCache.set(key, variableStatement);
+  }
+
+  return variableStatement;
 }
 
-function sanitizeMemberName(name: string) {
+export function sanitizeMemberName(name: string) {
   let sanitizedName = name.replace(JS_ENUM_INVALID_CHARS_RE, (c) => {
     const last = c[c.length - 1];
     return JS_PROPERTY_INDEX_INVALID_CHARS_RE.test(last) ? "" : last.toUpperCase();
@@ -298,7 +318,7 @@ function sanitizeMemberName(name: string) {
 }
 
 /** Sanitize TS enum member expression */
-export function tsEnumMember(value: string | number, metadata: { name?: string; description?: string } = {}) {
+export function tsEnumMember(value: string | number, metadata: EnumMemberMetadata = {}) {
   let name = metadata.name ?? String(value);
   if (!JS_PROPERTY_INDEX_RE.test(name)) {
     if (Number(name[0]) >= 0) {
@@ -418,19 +438,40 @@ export function tsLiteral(value: unknown): ts.TypeNode {
   return UNKNOWN;
 }
 
+/**
+ * Create a literal value (different from a literal type), such as a string or number
+ */
+export function tsLiteralValue(value: string | number, metadata?: EnumMemberMetadata) {
+  const literalExpression =
+    (typeof value === "number" && value < 0
+      ? ts.factory.createPrefixUnaryExpression(
+          ts.SyntaxKind.MinusToken,
+          ts.factory.createNumericLiteral(Math.abs(value)),
+        )
+      : undefined) ??
+    (typeof value === "number" ? ts.factory.createNumericLiteral(value) : undefined) ??
+    (typeof value === "string" ? ts.factory.createStringLiteral(value) : undefined);
+
+  if (literalExpression && metadata?.description) {
+    return ts.addSyntheticLeadingComment(
+      literalExpression,
+      ts.SyntaxKind.SingleLineCommentTrivia,
+      " ".concat(metadata.description.trim()),
+    );
+  }
+
+  return literalExpression;
+}
+
 /** Modifiers (readonly) */
 export function tsModifiers(modifiers: {
   readonly?: boolean;
   export?: boolean;
 }): ts.Modifier[] {
-  const typeMods: ts.Modifier[] = [];
-  if (modifiers.export) {
-    typeMods.push(ts.factory.createModifier(ts.SyntaxKind.ExportKeyword));
-  }
-  if (modifiers.readonly) {
-    typeMods.push(ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword));
-  }
-  return typeMods;
+  return [
+    modifiers.export ? ts.factory.createModifier(ts.SyntaxKind.ExportKeyword) : undefined,
+    modifiers.readonly ? ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword) : undefined,
+  ].filter((modifier) => modifier !== undefined);
 }
 
 /** Create a T | null union */
@@ -475,20 +516,23 @@ export function tsUnion(types: ts.TypeNode[]): ts.TypeNode {
   return ts.factory.createUnionTypeNode(tsDedupe(types));
 }
 
+const withRequiredHelper: ts.Node = stringToAST(
+  "type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };",
+)[0] as ts.Node;
+
 /** Create a WithRequired<X, Y> type */
 export function tsWithRequired(
   type: ts.TypeNode,
   keys: string[],
-  injectFooter: ts.Node[], // needed to inject type helper if used
+  inject: ts.Node[], // needed to inject type helper if used
 ): ts.TypeNode {
   if (keys.length === 0) {
     return type;
   }
 
   // inject helper, if needed
-  if (!injectFooter.some((node) => ts.isTypeAliasDeclaration(node) && node?.name?.escapedText === "WithRequired")) {
-    const helper = stringToAST("type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };")[0] as any;
-    injectFooter.push(helper);
+  if (!inject.includes(withRequiredHelper)) {
+    inject.push(withRequiredHelper);
   }
 
   return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("WithRequired"), [
@@ -497,20 +541,19 @@ export function tsWithRequired(
   ]);
 }
 
+const readonlyArrayHelper: ts.Node = stringToAST(
+  "type ReadonlyArray<T> = [Exclude<T, undefined>] extends [any[]] ? Readonly<Exclude<T, undefined>> : Readonly<Exclude<T, undefined>[]>;",
+)[0] as ts.Node;
+
 /**
  * Enhanced ReadonlyArray.
  * eg: type Foo = ReadonlyArray<T>; type Bar = ReadonlyArray<T[]>
  * Foo and Bar are both of type `readonly T[]`
  */
-export function tsReadonlyArray(type: ts.TypeNode, injectFooter?: ts.Node[]): ts.TypeNode {
-  if (
-    injectFooter &&
-    !injectFooter.some((node) => ts.isTypeAliasDeclaration(node) && node?.name?.escapedText === "ReadonlyArray")
-  ) {
-    const helper = stringToAST(
-      "type ReadonlyArray<T> = [Exclude<T, undefined>] extends [any[]] ? Readonly<Exclude<T, undefined>> : Readonly<Exclude<T, undefined>[]>;",
-    )[0] as any;
-    injectFooter.push(helper);
+export function tsReadonlyArray(type: ts.TypeNode, inject?: ts.Node[]): ts.TypeNode {
+  if (inject && !inject.includes(readonlyArrayHelper)) {
+    inject.push(readonlyArrayHelper);
   }
+
   return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReadonlyArray"), [type]);
 }
diff --git a/packages/openapi-typescript/src/transform/components-object.ts b/packages/openapi-typescript/src/transform/components-object.ts
index 47a5a8f71..e5c100d26 100644
--- a/packages/openapi-typescript/src/transform/components-object.ts
+++ b/packages/openapi-typescript/src/transform/components-object.ts
@@ -34,16 +34,18 @@ export default function transformComponentsObject(componentsObject: ComponentsOb
 
     const items: ts.TypeElement[] = [];
     if (componentsObject[key]) {
-      for (const [name, item] of getEntries(componentsObject[key], ctx)) {
+      for (const [name, item] of getEntries<SchemaObject>(componentsObject[key], ctx)) {
         let subType = transformers[key](item, {
           path: createRef(["components", key, name]),
+          schema: item,
           ctx,
         });
 
         let hasQuestionToken = false;
         if (ctx.transform) {
-          const result = ctx.transform(item as SchemaObject, {
+          const result = ctx.transform(item, {
             path: createRef(["components", key, name]),
+            schema: item,
             ctx,
           });
           if (result) {
diff --git a/packages/openapi-typescript/src/transform/index.ts b/packages/openapi-typescript/src/transform/index.ts
index 52d7e5801..3a38b1830 100644
--- a/packages/openapi-typescript/src/transform/index.ts
+++ b/packages/openapi-typescript/src/transform/index.ts
@@ -1,4 +1,4 @@
-import ts, { type InterfaceDeclaration, type TypeLiteralNode } from "typescript";
+import ts, { type TypeLiteralNode } from "typescript";
 import { performance } from "node:perf_hooks";
 import { NEVER, STRING, stringToAST, tsModifiers, tsRecord } from "../lib/ts.js";
 import { createRef, debug } from "../lib/utils.js";
@@ -15,17 +15,19 @@ const transformers: Record<SchemaTransforms, (node: any, options: GlobalContext)
   paths: transformPathsObject,
   webhooks: transformWebhooksObject,
   components: transformComponentsObject,
-  $defs: (node, options) => transformSchemaObject(node, { path: createRef(["$defs"]), ctx: options }),
+  $defs: (node, options) => transformSchemaObject(node, { path: createRef(["$defs"]), ctx: options, schema: node }),
 };
 
-export default function transformSchema(schema: OpenAPI3, ctx: GlobalContext) {
-  const type: ts.Node[] = [];
+function isOperationsInterfaceNode(node: ts.Node) {
+  const interfaceDeclaration = ts.isInterfaceDeclaration(node) ? node : undefined;
+  return interfaceDeclaration?.name.escapedText === "operations";
+}
 
-  if (ctx.inject) {
-    const injectNodes = stringToAST(ctx.inject) as ts.Node[];
-    type.push(...injectNodes);
-  }
+export default function transformSchema(schema: OpenAPI3, ctx: GlobalContext) {
+  const schemaNodes: ts.Node[] = [];
 
+  // Traverse the schema root elements, gathering type information and accumulating
+  // supporting nodes in `cts.injectNodes`.
   for (const root of Object.keys(transformers) as SchemaTransforms[]) {
     const emptyObj = ts.factory.createTypeAliasDeclaration(
       /* modifiers      */ tsModifiers({ export: true }),
@@ -40,7 +42,7 @@ export default function transformSchema(schema: OpenAPI3, ctx: GlobalContext) {
       for (const subType of subTypes) {
         if (ts.isTypeNode(subType)) {
           if ((subType as ts.TypeLiteralNode).members?.length) {
-            type.push(
+            schemaNodes.push(
               ctx.exportType
                 ? ts.factory.createTypeAliasDeclaration(
                     /* modifiers      */ tsModifiers({ export: true }),
@@ -58,45 +60,44 @@ export default function transformSchema(schema: OpenAPI3, ctx: GlobalContext) {
             );
             debug(`${root} done`, "ts", performance.now() - rootT);
           } else {
-            type.push(emptyObj);
+            schemaNodes.push(emptyObj);
             debug(`${root} done (skipped)`, "ts", 0);
           }
         } else if (ts.isTypeAliasDeclaration(subType)) {
-          type.push(subType);
+          schemaNodes.push(subType);
         } else {
-          type.push(emptyObj);
+          schemaNodes.push(emptyObj);
           debug(`${root} done (skipped)`, "ts", 0);
         }
       }
     } else {
-      type.push(emptyObj);
+      schemaNodes.push(emptyObj);
       debug(`${root} done (skipped)`, "ts", 0);
     }
   }
 
-  // inject
-  let hasOperations = false;
-  for (const injectedType of ctx.injectFooter) {
-    if (!hasOperations && (injectedType as InterfaceDeclaration)?.name?.escapedText === "operations") {
-      hasOperations = true;
-    }
-    type.push(injectedType);
-  }
-  if (!hasOperations) {
-    // if no operations created, inject empty operations type
-    type.push(
-      ts.factory.createTypeAliasDeclaration(
+  // Identify any operations node that was injected during traversal
+  const operationsNodeIndex = ctx.injectNodes.findIndex(isOperationsInterfaceNode);
+  const hasOperations = operationsNodeIndex !== -1;
+  const operationsNode = hasOperations
+    ? ctx.injectNodes.at(operationsNodeIndex)
+    : ts.factory.createTypeAliasDeclaration(
         /* modifiers      */ tsModifiers({ export: true }),
         /* name           */ "operations",
         /* typeParameters */ undefined,
         /* type           */ tsRecord(STRING, NEVER),
-      ),
-    );
-  }
-
-  if (ctx.makePathsEnum && schema.paths) {
-    type.push(makeApiPathsEnum(schema.paths));
-  }
+      );
 
-  return type;
+  return [
+    // Inject user-defined header
+    ...(ctx.inject ? (stringToAST(ctx.inject) as ts.Node[]) : []),
+    // Inject gathered values and types, except operations
+    ...ctx.injectNodes.filter((node) => node !== operationsNode),
+    // Inject schema
+    ...schemaNodes,
+    // Inject operations
+    ...(operationsNode ? [operationsNode] : []),
+    // Inject paths enum
+    ...(ctx.makePathsEnum && schema.paths ? [makeApiPathsEnum(schema.paths)] : []),
+  ];
 }
diff --git a/packages/openapi-typescript/src/transform/operation-object.ts b/packages/openapi-typescript/src/transform/operation-object.ts
index 16f3c25e8..d396c86e8 100644
--- a/packages/openapi-typescript/src/transform/operation-object.ts
+++ b/packages/openapi-typescript/src/transform/operation-object.ts
@@ -72,7 +72,7 @@ export function injectOperationObject(
   options: TransformNodeOptions,
 ): void {
   // find or create top-level operations interface
-  let operations = options.ctx.injectFooter.find(
+  let operations = options.ctx.injectNodes.find(
     (node) => ts.isInterfaceDeclaration(node) && (node as ts.InterfaceDeclaration).name.text === "operations",
   ) as unknown as ts.InterfaceDeclaration;
   if (!operations) {
@@ -86,7 +86,7 @@ export function injectOperationObject(
       /* heritageClauses */ undefined,
       /* members         */ [],
     );
-    options.ctx.injectFooter.push(operations);
+    options.ctx.injectNodes.push(operations);
   }
 
   // inject operation object
diff --git a/packages/openapi-typescript/src/transform/schema-object.ts b/packages/openapi-typescript/src/transform/schema-object.ts
index 983a92018..bc7ae14d2 100644
--- a/packages/openapi-typescript/src/transform/schema-object.ts
+++ b/packages/openapi-typescript/src/transform/schema-object.ts
@@ -2,6 +2,7 @@ import { parseRef } from "@redocly/openapi-core/lib/ref-utils.js";
 import ts from "typescript";
 import {
   BOOLEAN,
+  type EnumMemberMetadata,
   NEVER,
   NULL,
   NUMBER,
@@ -12,6 +13,7 @@ import {
   addJSDocComment,
   astToString,
   oapiRef,
+  sanitizeMemberName,
   tsArrayLiteralExpression,
   tsEnum,
   tsIntersection,
@@ -37,13 +39,264 @@ export default function transformSchemaObject(
   options: TransformNodeOptions,
 ): ts.TypeNode {
   const type = transformSchemaObjectWithComposition(schemaObject, options);
-  if (typeof options.ctx.postTransform === "function") {
-    const postTransformResult = options.ctx.postTransform(type, options);
-    if (postTransformResult) {
-      return postTransformResult;
+  const postTransformType =
+    typeof options.ctx.postTransform === "function" ? options.ctx.postTransform(type, options) : undefined;
+
+  return postTransformType ?? type;
+}
+
+function isEnumMemberLiteral(value: any): value is string | number | null {
+  return value === null || typeof value === "number" || typeof value === "string";
+}
+type EnumSchemaMember = Exclude<SchemaObject["enum"], undefined>;
+type EnumSchemaObject = SchemaObject & {
+  readonly additionalProperties: never;
+  readonly enum: readonly EnumSchemaMember[];
+  readonly properties: never;
+};
+
+function isEnumSchemaObject(schemaObject: SchemaObject): schemaObject is EnumSchemaObject {
+  return (
+    Array.isArray(schemaObject.enum) &&
+    schemaObject.enum.length > 0 &&
+    (!("type" in schemaObject) || schemaObject.type !== "object") &&
+    !("properties" in schemaObject) &&
+    !("additionalProperties" in schemaObject)
+  );
+}
+
+function schemaObjectToEnumMemberMetadata(schemaObject: EnumSchemaObject): EnumMemberMetadata[] {
+  return schemaObject.enum.map((_, index) => {
+    return {
+      name: schemaObject["x-enum-varnames"]?.[index] ?? schemaObject["x-enumNames"]?.[index],
+      description: schemaObject["x-enum-descriptions"]?.[index] ?? schemaObject["x-enumDescriptions"]?.[index],
+    };
+  });
+}
+
+function transformEnumSchemaObjectToUnion(schemaObject: EnumSchemaObject) {
+  const isNullable =
+    ((Array.isArray(schemaObject.type) && schemaObject.type.includes("null")) || schemaObject.nullable) &&
+    !schemaObject.default;
+
+  const enumType = schemaObject.enum.map(tsLiteral);
+
+  return tsUnion(isNullable ? enumType.concat(NULL) : enumType);
+}
+
+const createTypePredicateHelper = ts.factory.createFunctionDeclaration(
+  /* modifiers */ undefined,
+  /* asteriskToken */ undefined,
+  /* name */ ts.factory.createIdentifier("get_is"),
+  /* typeParameters */ [
+    ts.factory.createTypeParameterDeclaration(
+      /* modifiers   */ undefined,
+      /* name        */ ts.factory.createIdentifier("TItem"),
+      /* constraint  */ tsUnion([NUMBER, STRING]),
+      /* defaultType */ undefined,
+    ),
+  ],
+  /* parameters */ [
+    ts.factory.createParameterDeclaration(
+      /* modifiers      */ undefined,
+      /* dotDotDotToken */ undefined,
+      /* name           */ ts.factory.createIdentifier("items"),
+      /* questionToken  */ undefined,
+      /* type           */ ts.factory.createTypeOperatorNode(
+        /* operator */ ts.SyntaxKind.ReadonlyKeyword,
+        /* type     */ ts.factory.createArrayTypeNode(
+          /* elementType */ ts.factory.createTypeReferenceNode(
+            /* typeName      */ ts.factory.createIdentifier("TItem"),
+            /* typeArguments */ undefined,
+          ),
+        ),
+      ),
+      /* initializer    */ undefined,
+    ),
+  ],
+  /* type */ undefined,
+  /* body */ ts.factory.createBlock(
+    /* statements */ [
+      ts.factory.createReturnStatement(
+        ts.factory.createArrowFunction(
+          /* modifiers              */ undefined,
+          /* typeParameters         */ undefined,
+          /* parameters             */ [
+            ts.factory.createParameterDeclaration(
+              /* modifiers      */ undefined,
+              /* dotDotDotToken */ undefined,
+              /* name           */ ts.factory.createIdentifier("value"),
+              /* questionToken  */ undefined,
+              /* type           */ tsUnion([NULL, NUMBER, STRING, UNDEFINED]),
+              /* initializer    */ undefined,
+            ),
+          ],
+          /* type                   */ ts.factory.createTypePredicateNode(
+            /* assertsModifier */ undefined,
+            /* parameterName   */ ts.factory.createIdentifier("value"),
+            /* type            */ ts.factory.createTypeReferenceNode("TItem"),
+          ),
+          /* equalsGreaterThanToken */ ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+          /* body                   */ ts.factory.createBlock(
+            /* statements */ [
+              ts.factory.createReturnStatement(
+                /* expression */ ts.factory.createBinaryExpression(
+                  /* left      */ ts.factory.createBinaryExpression(
+                    /* left     */ ts.factory.createBinaryExpression(
+                      /* left    */ ts.factory.createIdentifier("value"),
+                      /* operator*/ ts.SyntaxKind.ExclamationEqualsEqualsToken,
+                      /* right   */ ts.factory.createIdentifier("null"),
+                    ),
+                    /* operator */ ts.SyntaxKind.AmpersandAmpersandToken,
+                    /* right    */ ts.factory.createBinaryExpression(
+                      /* left     */ ts.factory.createIdentifier("value"),
+                      /* operator */ ts.SyntaxKind.ExclamationEqualsEqualsToken,
+                      /* right    */ ts.factory.createIdentifier("undefined"),
+                    ),
+                  ),
+                  /* operator  */ ts.SyntaxKind.AmpersandAmpersandToken,
+                  /* right */ ts.factory.createCallExpression(
+                    /* expression     */ ts.factory.createPropertyAccessExpression(
+                      /* expression */ ts.factory.createIdentifier("items"),
+                      /* name       */ ts.factory.createIdentifier("includes"),
+                    ),
+                    /* typeArguments  */ undefined,
+                    /* argumentsArray */ [
+                      ts.factory.createAsExpression(
+                        /* expression */ ts.factory.createIdentifier("value"),
+                        /* type       */ ts.factory.createTypeReferenceNode(
+                          /* typeName      */ ts.factory.createIdentifier("TItem"),
+                          /* typeArguments */ undefined,
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+            ],
+            /* multiLine  */ true,
+          ),
+        ),
+      ),
+    ],
+    /* multiline */ true,
+  ),
+);
+
+function getTypePredicate(constName: string, constTypeName: string, options: TransformNodeOptions) {
+  if (!options.ctx.injectNodes.includes(createTypePredicateHelper)) {
+    options.ctx.injectNodes.push(createTypePredicateHelper);
+  }
+
+  return ts.factory.createVariableStatement(
+    /* modifiers       */ tsModifiers({ export: true }),
+    /* declarationList */ ts.factory.createVariableDeclarationList(
+      /* declarations */ [
+        ts.factory.createVariableDeclaration(
+          /* name             */ ts.factory.createIdentifier(`is_${constTypeName}`),
+          /* exclamationToken */ undefined,
+          /* type             */ undefined,
+          /* initializer      */ ts.factory.createCallExpression(
+            /* expression */ ts.factory.createIdentifier("get_is"),
+            /* typeArguments */ [ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(constTypeName))],
+            /* argumentsArray */ [ts.factory.createIdentifier(constName)],
+          ),
+        ),
+      ],
+      /* flags */ ts.NodeFlags.Const,
+    ),
+  );
+}
+
+function transformEnumSchemaObject(schemaObject: EnumSchemaObject, options: TransformNodeOptions) {
+  // If the `enum` or `enumValues` options are enabled, create and hoist the declarations
+  // for the enum and array, so long as all enum members are string or number literals.
+  const enumMembers = schemaObject.enum;
+  // First filter the enum members down to just the literals; this aids in narrowing the type
+  // of the values.
+  const initialEnumMemberLiterals = enumMembers.filter(isEnumMemberLiteral);
+  // After filtering & narrowing, ensure that all the members are literals by comparing the lengths
+  // of the filtered and unfiltered lists.
+  // If the lengths differ, this enum is not valid for transformation.
+  const enumMemberLiterals =
+    initialEnumMemberLiterals.length === enumMembers.length ? initialEnumMemberLiterals : undefined;
+
+  if (!(enumMemberLiterals?.length && (options.ctx.enum || options.ctx.enumValues))) {
+    return transformEnumSchemaObjectToUnion(schemaObject);
+  }
+
+  // The enum qualifies for extraction at this point, either as a TypeScript enum
+  // or as an array of values.
+  // Allow #/components/schemas to have simpler names
+  const enumName = parseRef(options.path ?? "")
+    .pointer.join("/")
+    .replace("components/schemas", "");
+
+  const metadata = schemaObjectToEnumMemberMetadata(schemaObject);
+
+  // OpenAPI enums can contain null values, but we don't want to output them
+  const hasNull = enumMembers.some((enumValue) => enumValue === null);
+  const members = enumMembers.filter(isEnumMemberLiteral).filter((enumValue) => enumValue !== null);
+
+  const enumType = options.ctx.enum
+    ? tsEnum(
+        // tsEnum performs its own sanitization on enumName
+        enumName,
+        members,
+        metadata,
+        // TS enum do not support the readonly modifier
+        { shouldCache: options.ctx.dedupeEnums, export: true },
+      )
+    : undefined;
+
+  const constTypeName = options.ctx.enumValues ? sanitizeMemberName(enumName) : undefined;
+  const constName = options.ctx.enumValues && constTypeName ? `${constTypeName}Values` : undefined;
+
+  const constExpression =
+    options.ctx.enumValues && constName
+      ? tsArrayLiteralExpression(
+          /* name        */ constName,
+          /* elementType */ undefined,
+          /* members     */ members,
+          /* metadata    */ metadata,
+          /* options     */ { shouldCache: options.ctx.dedupeEnums, export: true },
+        )
+      : undefined;
+
+  const constMemberType =
+    options.ctx.enumValues && constName && constTypeName
+      ? ts.factory.createTypeAliasDeclaration(
+          /* modifiers      */ tsModifiers({ export: true }),
+          /* name           */ constTypeName,
+          /* typeParameters */ undefined,
+          /* type           */ ts.factory.createIndexedAccessTypeNode(
+            ts.factory.createTypeQueryNode(ts.factory.createIdentifier(constName)),
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+          ),
+        )
+      : undefined;
+
+  const constTypePredicate =
+    options.ctx.enumValues && constName && constTypeName
+      ? getTypePredicate(constName, constTypeName, options)
+      : undefined;
+
+  // Add declarations for all selected output types.
+  for (const node of [enumType, constExpression, constMemberType, constTypePredicate]) {
+    if (node && !options.ctx.injectNodes.includes(node)) {
+      options.ctx.injectNodes.push(node);
     }
   }
-  return type;
+
+  const refName = (enumType ? enumType.name : undefined) ?? (constMemberType ? constMemberType.name : undefined);
+
+  const ref = refName ? ts.factory.createTypeReferenceNode(refName) : undefined;
+
+  if (!ref) {
+    return NULL;
+  }
+
+  return hasNull ? tsUnion([ref, NULL].filter((node) => node !== undefined)) : ref;
 }
 
 /**
@@ -90,78 +343,9 @@ export function transformSchemaObjectWithComposition(
    * enum (non-objects)
    * note: enum is valid for any type, but for objects, handle in oneOf below
    */
-  if (
-    Array.isArray(schemaObject.enum) &&
-    (!("type" in schemaObject) || schemaObject.type !== "object") &&
-    !("properties" in schemaObject) &&
-    !("additionalProperties" in schemaObject)
-  ) {
-    // hoist enum to top level if string/number enum and option is enabled
-    if (
-      options.ctx.enum &&
-      schemaObject.enum.every((v) => typeof v === "string" || typeof v === "number" || v === null)
-    ) {
-      let enumName = parseRef(options.path ?? "").pointer.join("/");
-      // allow #/components/schemas to have simpler names
-      enumName = enumName.replace("components/schemas", "");
-      const metadata = schemaObject.enum.map((_, i) => ({
-        name: schemaObject["x-enum-varnames"]?.[i] ?? schemaObject["x-enumNames"]?.[i],
-        description: schemaObject["x-enum-descriptions"]?.[i] ?? schemaObject["x-enumDescriptions"]?.[i],
-      }));
-
-      // enums can contain null values, but dont want to output them
-      let hasNull = false;
-      const validSchemaEnums = schemaObject.enum.filter((enumValue) => {
-        if (enumValue === null) {
-          hasNull = true;
-          return false;
-        }
-
-        return true;
-      });
-      const enumType = tsEnum(enumName, validSchemaEnums as (string | number)[], metadata, {
-        shouldCache: options.ctx.dedupeEnums,
-        export: true,
-        // readonly: TS enum do not support the readonly modifier
-      });
-      if (!options.ctx.injectFooter.includes(enumType)) {
-        options.ctx.injectFooter.push(enumType);
-      }
-      const ref = ts.factory.createTypeReferenceNode(enumType.name);
-      return hasNull ? tsUnion([ref, NULL]) : ref;
-    }
-    const enumType = schemaObject.enum.map(tsLiteral);
-    if (
-      ((Array.isArray(schemaObject.type) && schemaObject.type.includes("null")) || schemaObject.nullable) &&
-      !schemaObject.default
-    ) {
-      enumType.push(NULL);
-    }
-
-    const unionType = tsUnion(enumType);
-
-    // hoist array with valid enum values to top level if string/number enum and option is enabled
-    if (options.ctx.enumValues && schemaObject.enum.every((v) => typeof v === "string" || typeof v === "number")) {
-      let enumValuesVariableName = parseRef(options.path ?? "").pointer.join("/");
-      // allow #/components/schemas to have simpler names
-      enumValuesVariableName = enumValuesVariableName.replace("components/schemas", "");
-      enumValuesVariableName = `${enumValuesVariableName}Values`;
-
-      const enumValuesArray = tsArrayLiteralExpression(
-        enumValuesVariableName,
-        oapiRef(options.path ?? ""),
-        schemaObject.enum as (string | number)[],
-        {
-          export: true,
-          readonly: true,
-          injectFooter: options.ctx.injectFooter,
-        },
-      );
-
-      options.ctx.injectFooter.push(enumValuesArray);
-    }
-
-    return unionType;
+  const enumSchemaObject = isEnumSchemaObject(schemaObject) ? schemaObject : undefined;
+  if (enumSchemaObject) {
+    return transformEnumSchemaObject(enumSchemaObject, options);
   }
 
   /**
@@ -169,13 +353,15 @@ export function transformSchemaObjectWithComposition(
    */
 
   /** Collect oneOf/anyOf */
-  function collectUnionCompositions(items: (SchemaObject | ReferenceObject)[]) {
-    const output: ts.TypeNode[] = [];
-    for (const item of items) {
-      output.push(transformSchemaObject(item, options));
-    }
-
-    return output;
+  function collectUnionCompositions(schemaObject: SchemaObject, items: (SchemaObject | ReferenceObject)[]) {
+    const compositionType =
+      (schemaObject.allOf ? "allOf" : undefined) ??
+      (schemaObject.anyOf ? "anyOf" : undefined) ??
+      (schemaObject.oneOf ? "oneOf" : undefined);
+
+    return items.map((item, index) =>
+      transformSchemaObject(item, { ...options, path: createRef([options.path, compositionType, index]) }),
+    );
   }
 
   /** Collect allOf with Omit<> for discriminators */
@@ -201,7 +387,7 @@ export function transformSchemaObjectWithComposition(
           // add WithRequired<X, Y> if necessary
           const validRequired = (required ?? []).filter((key) => !!resolved.properties?.[key]);
           if (validRequired.length) {
-            itemType = tsWithRequired(itemType, validRequired, options.ctx.injectFooter);
+            itemType = tsWithRequired(itemType, validRequired, options.ctx.injectNodes);
           }
         }
       }
@@ -237,12 +423,13 @@ export function transformSchemaObjectWithComposition(
   }
   // anyOf: union
   // (note: this may seem counterintuitive, but as TypeScript’s unions are not true XORs, they mimic behavior closer to anyOf than oneOf)
-  const anyOfType = collectUnionCompositions(schemaObject.anyOf ?? []);
+  const anyOfType = collectUnionCompositions(schemaObject, schemaObject.anyOf ?? []);
   if (anyOfType.length) {
     finalType = tsUnion([...(finalType ? [finalType] : []), ...anyOfType]);
   }
   // oneOf: union (within intersection with other types, if any)
   const oneOfType = collectUnionCompositions(
+    schemaObject,
     schemaObject.oneOf ||
       ("type" in schemaObject &&
         schemaObject.type === "object" &&
diff --git a/packages/openapi-typescript/src/types.ts b/packages/openapi-typescript/src/types.ts
index 59dabcbe9..7a424a863 100644
--- a/packages/openapi-typescript/src/types.ts
+++ b/packages/openapi-typescript/src/types.ts
@@ -690,7 +690,7 @@ export interface GlobalContext {
   excludeDeprecated: boolean;
   exportType: boolean;
   immutable: boolean;
-  injectFooter: ts.Node[];
+  injectNodes: ts.Node[];
   pathParamsAsTypes: boolean;
   postTransform: OpenAPITSOptions["postTransform"];
   propertiesRequiredByDefault: boolean;
@@ -710,5 +710,6 @@ export type $defs = Record<string, SchemaObject>;
 /** generic options for most internal transform* functions */
 export interface TransformNodeOptions {
   path?: string;
+  schema?: SchemaObject | ReferenceObject;
   ctx: GlobalContext;
 }
diff --git a/packages/openapi-typescript/test/cjs.test.js b/packages/openapi-typescript/test/cjs.test.js
index a20f54d47..a00bbb198 100644
--- a/packages/openapi-typescript/test/cjs.test.js
+++ b/packages/openapi-typescript/test/cjs.test.js
@@ -14,7 +14,7 @@ describe("CJS bundle", () => {
  */
 
 ${astToString(await openapiTS(new URL("../examples/stripe-api.yaml", import.meta.url)))}`;
-      expect(output).toMatchFileSnapshot(fileURLToPath(new URL("../examples/stripe-api.ts", import.meta.url)));
+      await expect(output).toMatchFileSnapshot(fileURLToPath(new URL("../examples/stripe-api.ts", import.meta.url)));
     },
     { timeout: TIMEOUT },
   );
diff --git a/packages/openapi-typescript/test/cli.test.ts b/packages/openapi-typescript/test/cli.test.ts
index 448820bbf..fdd453ee6 100644
--- a/packages/openapi-typescript/test/cli.test.ts
+++ b/packages/openapi-typescript/test/cli.test.ts
@@ -84,7 +84,7 @@ describe("CLI", () => {
       async () => {
         const { stdout } = await execa(cmd, given, { cwd });
         if (want instanceof URL) {
-          expect(stdout).toMatchFileSnapshot(fileURLToPath(want));
+          await expect(stdout).toMatchFileSnapshot(fileURLToPath(want));
         } else {
           expect(stdout).toBe(`${want}\n`);
         }
@@ -145,7 +145,7 @@ describe("CLI", () => {
         cwd,
       });
       for (const schema of ["a", "b", "c"]) {
-        expect(
+        await expect(
           fs.readFileSync(new URL(`./test/fixtures/redocly-flag/output/${schema}.ts`, root), "utf8"),
         ).toMatchFileSnapshot(fileURLToPath(new URL("./examples/simple-example.ts", root)));
       }
diff --git a/packages/openapi-typescript/test/index.test.ts b/packages/openapi-typescript/test/index.test.ts
index 0789d6757..baff326b7 100644
--- a/packages/openapi-typescript/test/index.test.ts
+++ b/packages/openapi-typescript/test/index.test.ts
@@ -636,7 +636,10 @@ export type operations = Record<string, never>;`,
             },
           },
         },
-        want: `export type paths = Record<string, never>;
+        want: `type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type paths = Record<string, never>;
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
@@ -661,9 +664,6 @@ export interface components {
     pathItems: never;
 }
 export type $defs = Record<string, never>;
-type WithRequired<T, K extends keyof T> = T & {
-    [P in K]-?: T[P];
-};
 export type operations = Record<string, never>;`,
         // options: DEFAULT_OPTIONS,
       },
diff --git a/packages/openapi-typescript/test/lib/ts.test.ts b/packages/openapi-typescript/test/lib/ts.test.ts
index e7a1fd992..882753bc6 100644
--- a/packages/openapi-typescript/test/lib/ts.test.ts
+++ b/packages/openapi-typescript/test/lib/ts.test.ts
@@ -228,27 +228,64 @@ describe("tsArrayLiteralExpression", () => {
       astToString(
         tsArrayLiteralExpression("-my-color-Values", oapiRef("#/components/schemas/Color"), ["green", "red", "blue"]),
       ).trim(),
-    ).toBe(`const myColorValues: components["schemas"]["Color"][] = ["green", "red", "blue"];`);
+    ).toBe(`const MyColorValues: components["schemas"]["Color"][] = ["green", "red", "blue"];`);
   });
 
   test("with setting: export", () => {
     expect(
       astToString(
-        tsArrayLiteralExpression("-my-color-Values", oapiRef("#/components/schemas/Color"), ["green", "red", "blue"], {
-          export: true,
-        }),
+        tsArrayLiteralExpression(
+          "-my-color-Values",
+          oapiRef("#/components/schemas/Color"),
+          ["green", "red", "blue"],
+          undefined,
+          {
+            export: true,
+          },
+        ),
       ).trim(),
-    ).toBe(`export const myColorValues: components["schemas"]["Color"][] = ["green", "red", "blue"];`);
+    ).toBe(`export const MyColorValues: components["schemas"]["Color"][] = ["green", "red", "blue"];`);
   });
 
   test("with setting: readonly", () => {
     expect(
       astToString(
-        tsArrayLiteralExpression("-my-color-Values", oapiRef("#/components/schemas/Color"), ["green", "red", "blue"], {
-          readonly: true,
-        }),
+        tsArrayLiteralExpression(
+          "-my-color-Values",
+          oapiRef("#/components/schemas/Color"),
+          ["green", "red", "blue"],
+          undefined,
+          {
+            readonly: true,
+          },
+        ),
       ).trim(),
-    ).toBe(`const myColorValues: ReadonlyArray<components["schemas"]["Color"]> = ["green", "red", "blue"];`);
+    ).toBe(`const MyColorValues: ReadonlyArray<components["schemas"]["Color"]> = ["green", "red", "blue"];`);
+  });
+
+  test("with metadata: name", () => {
+    expect(
+      astToString(
+        tsArrayLiteralExpression(
+          "-my-color-Values",
+          oapiRef("#/components/schemas/Color"),
+          ["green", "red", "blue"],
+          [{ description: "Healthy" }, { description: "Unhealthy" }, { description: "Booting" }],
+        ),
+      ).trim(),
+    ).toBe(`const MyColorValues: components["schemas"]["Color"][] = [
+    // Healthy
+    "green", 
+    // Unhealthy
+    "red", 
+    // Booting
+    "blue"];`);
+  });
+
+  test("with no element type", () => {
+    expect(astToString(tsArrayLiteralExpression("-my-color-Values", undefined, ["green", "red", "blue"])).trim()).toBe(
+      `const MyColorValues = ["green", "red", "blue"] as const;`,
+    );
   });
 
   test("name from path", () => {
@@ -260,7 +297,7 @@ describe("tsArrayLiteralExpression", () => {
           ["active", "inactive"],
         ),
       ).trim(),
-    ).toBe(`const pathsUrlGetParametersQueryStatusValues: components["schemas"]["Status"][] = ["active", "inactive"];`);
+    ).toBe(`const PathsUrlGetParametersQueryStatusValues: components["schemas"]["Status"][] = ["active", "inactive"];`);
   });
 
   test("number members", () => {
@@ -272,7 +309,7 @@ describe("tsArrayLiteralExpression", () => {
           [100, 101, 102, -100],
         ),
       ).trim(),
-    ).toBe(`const errorCodeValues: components["schemas"]["ErrorCode"][] = [100, 101, 102, -100];`);
+    ).toBe(`const ErrorCodeValues: components["schemas"]["ErrorCode"][] = [100, 101, 102, -100];`);
   });
 });
 
diff --git a/packages/openapi-typescript/test/node-api.test.ts b/packages/openapi-typescript/test/node-api.test.ts
index b0ff0c8f3..36396edf2 100644
--- a/packages/openapi-typescript/test/node-api.test.ts
+++ b/packages/openapi-typescript/test/node-api.test.ts
@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
 import openapiTS, { COMMENT_HEADER, astToString } from "../src/index.js";
-import type { OpenAPITSOptions } from "../src/types.js";
+import type { OpenAPITSOptions, ReferenceObject, SchemaObject } from "../src/types.js";
 import type { TestCase } from "./test-helpers.js";
 
 const EXAMPLES_DIR = new URL("../examples/", import.meta.url);
@@ -537,6 +537,11 @@ export type operations = Record<string, never>;`,
           components: {
             schemas: {
               Date: { type: "string", format: "date-time" },
+              Set: {
+                "x-string-enum-to-set": true,
+                type: "string",
+                enum: ["low", "medium", "high"],
+              },
             },
           },
         },
@@ -546,6 +551,8 @@ export interface components {
     schemas: {
         /** Format: date-time */
         Date: DateOrTime;
+        /** @enum {string} */
+        Set: Set<"low" | "medium" | "high">;
     };
     responses: never;
     parameters: never;
@@ -565,6 +572,32 @@ export type operations = Record<string, never>;`,
                */
               return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("DateOrTime"));
             }
+
+            // Previously, in order to access the schema in postTransform,
+            // you could resolve the schema using the path.
+            // Now, the schema is made available directly on the options.
+            // const schema = options.path
+            //   ? options.ctx.resolve<ReferenceObject | SchemaObject>(options.path)
+            //   : undefined;
+            const schema = options.schema;
+
+            if (
+              schema &&
+              !("$ref" in schema) &&
+              Object.hasOwn(schema, "x-string-enum-to-set") &&
+              schema.type === "string" &&
+              schema.enum?.every((enumMember) => {
+                return typeof enumMember === "string";
+              })
+            ) {
+              return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Set"), [
+                ts.factory.createUnionTypeNode(
+                  schema.enum.map((value) => {
+                    return ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(value));
+                  }),
+                ),
+              ]);
+            }
           },
         },
       },
@@ -590,6 +623,28 @@ export type operations = Record<string, never>;`,
                 ],
               },
             },
+            "/url2": {
+              get: {
+                parameters: [
+                  {
+                    name: "status",
+                    in: "query",
+                    schema: {
+                      anyOf: [
+                        {
+                          type: "string",
+                          enum: ["approved", "rejected"],
+                        },
+                        {
+                          type: "string",
+                          enum: ["appealed"],
+                        },
+                      ],
+                    },
+                  },
+                ],
+              },
+            },
           },
           components: {
             schemas: {
@@ -597,6 +652,17 @@ export type operations = Record<string, never>;`,
                 type: "string",
                 enum: ["active", "inactive"],
               },
+              ModeratedStatus: {
+                anyOf: [
+                  {
+                    $ref: "#/components/schemas/Status",
+                  },
+                  {
+                    type: "string",
+                    enum: ["appealed"],
+                  },
+                ],
+              },
               ErrorCode: {
                 type: "number",
                 enum: [100, 101, 102, 103, 104, 105],
@@ -624,7 +690,57 @@ export type operations = Record<string, never>;`,
             },
           },
         },
-        want: `export interface paths {
+        want: `export enum PathsUrlGetParametersQueryStatus {
+    active = "active",
+    inactive = "inactive"
+}
+export enum PathsUrl2GetParametersQueryStatusAnyOf0 {
+    approved = "approved",
+    rejected = "rejected"
+}
+export enum PathsUrl2GetParametersQueryStatusAnyOf1 {
+    appealed = "appealed"
+}
+export enum Status {
+    active = "active",
+    inactive = "inactive"
+}
+export enum ModeratedStatusAnyOf1 {
+    appealed = "appealed"
+}
+export enum ErrorCode {
+    Value100 = 100,
+    Value101 = 101,
+    Value102 = 102,
+    Value103 = 103,
+    Value104 = 104,
+    Value105 = 105
+}
+export enum XEnumVarnames {
+    // Used when the status of something is successful
+    Success = 0,
+    // Used when the status of something has a warning
+    Warning = 1,
+    // Used when the status of something has an error
+    Error = 2
+}
+export enum XEnumNames {
+    // El número uno
+    Uno = 1,
+    // El número dos
+    Dos = 2,
+    // El número tres
+    Tres = 3
+}
+export enum InvalidPropertyNameChars {
+    "=" = "=",
+    "!=" = "!=",
+    ">" = ">",
+    "~" = "~",
+    "^" = "^",
+    TE_ST = "TE=ST"
+}
+export interface paths {
     "/url": {
         parameters: {
             query?: never;
@@ -652,12 +768,40 @@ export type operations = Record<string, never>;`,
         patch?: never;
         trace?: never;
     };
+    "/url2": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: {
+                    status?: PathsUrl2GetParametersQueryStatusAnyOf0 | PathsUrl2GetParametersQueryStatusAnyOf1;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: never;
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
         /** @enum {string} */
         Status: Status;
+        ModeratedStatus: components["schemas"]["Status"] | ModeratedStatusAnyOf1;
         /** @enum {number} */
         ErrorCode: ErrorCode;
         /** @enum {number} */
@@ -674,46 +818,6 @@ export interface components {
     pathItems: never;
 }
 export type $defs = Record<string, never>;
-export enum PathsUrlGetParametersQueryStatus {
-    active = "active",
-    inactive = "inactive"
-}
-export enum Status {
-    active = "active",
-    inactive = "inactive"
-}
-export enum ErrorCode {
-    Value100 = 100,
-    Value101 = 101,
-    Value102 = 102,
-    Value103 = 103,
-    Value104 = 104,
-    Value105 = 105
-}
-export enum XEnumVarnames {
-    // Used when the status of something is successful
-    Success = 0,
-    // Used when the status of something has a warning
-    Warning = 1,
-    // Used when the status of something has an error
-    Error = 2
-}
-export enum XEnumNames {
-    // El número uno
-    Uno = 1,
-    // El número dos
-    Dos = 2,
-    // El número tres
-    Tres = 3
-}
-export enum InvalidPropertyNameChars {
-    "=" = "=",
-    "!=" = "!=",
-    ">" = ">",
-    "~" = "~",
-    "^" = "^",
-    TE_ST = "TE=ST"
-}
 export type operations = Record<string, never>;`,
         options: { enum: true },
       },
@@ -739,12 +843,43 @@ export type operations = Record<string, never>;`,
                 ],
               },
             },
+            "/url2": {
+              get: {
+                parameters: [
+                  {
+                    name: "status",
+                    in: "query",
+                    schema: {
+                      anyOf: [
+                        {
+                          type: "string",
+                          enum: ["approved", "rejected"],
+                        },
+                        {
+                          type: "string",
+                          enum: ["appealed"],
+                        },
+                      ],
+                    },
+                  },
+                ],
+              },
+            },
           },
           components: {
             schemas: {
               Status: {
-                type: "string",
-                enum: ["active", "inactive"],
+                anyOf: [
+                  {
+                    type: "string",
+                    enum: ["active", "inactive"],
+                  },
+                  {
+                    type: "string",
+                    deprecated: true,
+                    enum: ["pending"],
+                  },
+                ],
               },
               ErrorCode: {
                 type: "number",
@@ -753,7 +888,30 @@ export type operations = Record<string, never>;`,
             },
           },
         },
-        want: `export interface paths {
+        want: `function get_is<TItem extends number | string>(items: readonly TItem[]) {
+    return (value: null | number | string | undefined): value is TItem => {
+        return value !== null && value !== undefined && items.includes(value as TItem);
+    };
+}
+export const pathsUrlGetParametersQueryStatusValues = ["active", "inactive"] as const;
+export type pathsUrlGetParametersQueryStatus = (typeof pathsUrlGetParametersQueryStatusValues)[number];
+export const is_pathsUrlGetParametersQueryStatus = get_is<pathsUrlGetParametersQueryStatus>(pathsUrlGetParametersQueryStatusValues);
+export const pathsUrl2GetParametersQueryStatusAnyOf0Values = ["approved", "rejected"] as const;
+export type pathsUrl2GetParametersQueryStatusAnyOf0 = (typeof pathsUrl2GetParametersQueryStatusAnyOf0Values)[number];
+export const is_pathsUrl2GetParametersQueryStatusAnyOf0 = get_is<pathsUrl2GetParametersQueryStatusAnyOf0>(pathsUrl2GetParametersQueryStatusAnyOf0Values);
+export const pathsUrl2GetParametersQueryStatusAnyOf1Values = ["appealed"] as const;
+export type pathsUrl2GetParametersQueryStatusAnyOf1 = (typeof pathsUrl2GetParametersQueryStatusAnyOf1Values)[number];
+export const is_pathsUrl2GetParametersQueryStatusAnyOf1 = get_is<pathsUrl2GetParametersQueryStatusAnyOf1>(pathsUrl2GetParametersQueryStatusAnyOf1Values);
+export const StatusAnyOf0Values = ["active", "inactive"] as const;
+export type StatusAnyOf0 = (typeof StatusAnyOf0Values)[number];
+export const is_StatusAnyOf0 = get_is<StatusAnyOf0>(StatusAnyOf0Values);
+export const StatusAnyOf1Values = ["pending"] as const;
+export type StatusAnyOf1 = (typeof StatusAnyOf1Values)[number];
+export const is_StatusAnyOf1 = get_is<StatusAnyOf1>(StatusAnyOf1Values);
+export const ErrorCodeValues = [100, 101, 102, 103, 104, 105] as const;
+export type ErrorCode = (typeof ErrorCodeValues)[number];
+export const is_ErrorCode = get_is<ErrorCode>(ErrorCodeValues);
+export interface paths {
     "/url": {
         parameters: {
             query?: never;
@@ -764,7 +922,34 @@ export type operations = Record<string, never>;`,
         get: {
             parameters: {
                 query?: {
-                    status?: "active" | "inactive";
+                    status?: pathsUrlGetParametersQueryStatus;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: never;
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/url2": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: {
+                    status?: pathsUrl2GetParametersQueryStatusAnyOf0 | pathsUrl2GetParametersQueryStatusAnyOf1;
                 };
                 header?: never;
                 path?: never;
@@ -785,10 +970,9 @@ export type operations = Record<string, never>;`,
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
-        /** @enum {string} */
-        Status: "active" | "inactive";
+        Status: StatusAnyOf0 | StatusAnyOf1;
         /** @enum {number} */
-        ErrorCode: 100 | 101 | 102 | 103 | 104 | 105;
+        ErrorCode: ErrorCode;
     };
     responses: never;
     parameters: never;
@@ -797,14 +981,6 @@ export interface components {
     pathItems: never;
 }
 export type $defs = Record<string, never>;
-type ReadonlyArray<T> = [
-    Exclude<T, undefined>
-] extends [
-    any[]
-] ? Readonly<Exclude<T, undefined>> : Readonly<Exclude<T, undefined>[]>;
-export const pathsUrlGetParametersQueryStatusValues: ReadonlyArray<paths["/url"]["get"]["parameters"]["query"]["status"]> = ["active", "inactive"];
-export const statusValues: ReadonlyArray<components["schemas"]["Status"]> = ["active", "inactive"];
-export const errorCodeValues: ReadonlyArray<components["schemas"]["ErrorCode"]> = [100, 101, 102, 103, 104, 105];
 export type operations = Record<string, never>;`,
         options: { enumValues: true },
       },
@@ -844,7 +1020,11 @@ export type operations = Record<string, never>;`,
             },
           },
         },
-        want: `export interface paths {
+        want: `export enum PathsUrlGetParametersQueryStatus {
+    active = "active",
+    inactive = "inactive"
+}
+export interface paths {
     "/url": {
         parameters: {
             query?: never;
@@ -888,10 +1068,6 @@ export interface components {
     pathItems: never;
 }
 export type $defs = Record<string, never>;
-export enum PathsUrlGetParametersQueryStatus {
-    active = "active",
-    inactive = "inactive"
-}
 export type operations = Record<string, never>;`,
         options: { enum: true, dedupeEnums: true },
       },
@@ -949,7 +1125,7 @@ export type operations = Record<string, never>;`,
       async () => {
         const result = astToString(await openapiTS(given, options));
         if (want instanceof URL) {
-          expect(`${COMMENT_HEADER}${result}`).toMatchFileSnapshot(fileURLToPath(want));
+          await expect(`${COMMENT_HEADER}${result}`).toMatchFileSnapshot(fileURLToPath(want));
         } else {
           expect(result).toBe(`${want}\n`);
         }
diff --git a/packages/openapi-typescript/test/test-helpers.ts b/packages/openapi-typescript/test/test-helpers.ts
index 8354dbac8..96d6b19fe 100644
--- a/packages/openapi-typescript/test/test-helpers.ts
+++ b/packages/openapi-typescript/test/test-helpers.ts
@@ -19,7 +19,7 @@ export const DEFAULT_CTX: GlobalContext = {
   excludeDeprecated: false,
   exportType: false,
   immutable: false,
-  injectFooter: [],
+  injectNodes: [],
   pathParamsAsTypes: false,
   postTransform: undefined,
   propertiesRequiredByDefault: false,
diff --git a/packages/swr-openapi/package.json b/packages/swr-openapi/package.json
index d38d7da2d..827b25acc 100644
--- a/packages/swr-openapi/package.json
+++ b/packages/swr-openapi/package.json
@@ -56,8 +56,8 @@
     "version": "pnpm run build"
   },
   "peerDependencies": {
-    "openapi-fetch": "0.x",
-    "openapi-typescript": "7.x",
+    "openapi-fetch": "0.13.4",
+    "openapi-typescript": "7.5.1",
     "react": "18 || 19",
     "swr": "2",
     "typescript": "^5.x"