chore: update Angular plugin

dev/openapi-ts.config.ts

···
           path: path.resolve(
             getSpecsPath(),
             // '2.0.x',
-            '3.0.x',
-            // '3.1.x',
+            // '3.0.x',
+            '3.1.x',
             // 'circular.yaml',
             // 'dutchie.json',
             // 'enum-names-values.yaml',
···
             // 'invalid',
             // 'object-property-names.yaml',
             // 'openai.yaml',
-            // 'opencode.yaml',
+            'opencode.yaml',
             // 'pagination-ref.yaml',
             // 'schema-const.yaml',
             // 'sdk-instance.yaml',
-            'sdk-method-class-conflict.yaml',
+            // 'sdk-method-class-conflict.yaml',
             // 'sdk-nested-classes.yaml',
             // 'sdk-nested-conflict.yaml',
             // 'string-with-format.yaml',
···
         {
           // baseUrl: false,
           // exportFromIndex: true,
-          // name: '@hey-api/client-nuxt',
+          // name: '@hey-api/client-angular',
           // runtimeConfigPath: path.resolve(__dirname, 'hey-api.ts'),
           // runtimeConfigPath: './src/hey-api.ts',
           // strictBaseUrl: true,
···
           // },
         },
         {
-          // asClass: true,
+          asClass: true,
           // auth: false,
           // classNameBuilder: '{{name}}Service',
           // classStructure: 'off',
···
           //   fields.unwrap('path')
           // },
           // include...
-          // instance: 'OpencodeClient',
+          instance: 'OpencodeClient',
           // methodNameBuilder: '{{name}}',
           name: '@hey-api/sdk',
           // operationId: false,
···
           // signature: 'auto',
           // signature: 'client',
           // signature: 'object',
+          structure: {
+            operations: {
+              containerName: 'OpencodeClient',
+              strategy: 'single',
+            },
+          },
           // transformer: '@hey-api/transformers',
           // transformer: true,
           // validator: 'valibot',
···
           exportFromIndex: true,
           httpRequests: {
             asClass: true,
+            // enabled: false,
           },
           httpResources: {
-            asClass: true,
+            // asClass: true,
+            enabled: false,
           },
           // name: '@angular/common',
         },
         {
           exportFromIndex: true,
           // mutationOptions: '{{name}}Mutationssss',
-          name: '@pinia/colada',
+          // name: '@pinia/colada',
           // queryOptions: {
           //   name: '{{name}}Queryyyyy',
           // },

dev/package.json

···
     "dev": "ts-node ./playground.ts"
   },
   "devDependencies": {
+    "@angular/common": "19.2.17",
+    "@angular/core": "19.2.17",
     "@hey-api/codegen-core": "workspace:*",
     "@hey-api/openapi-ts": "workspace:*",
     "@opencode-ai/sdk": "1.0.170",

packages/codegen-core/src/__tests__/exports.test.ts

···
   index.Refs<any>,
   index.RenderContext,
   index.Renderer,
+  index.StructureInsert,
+  index.StructureItem,
+  index.StructureLocation,
+  index.StructureModel,
+  index.StructureNode,
+  index.StructureShell,
+  index.StructureShellResult,
   index.Symbol,
   index.SymbolIdentifier,
   index.SymbolIn,

packages/codegen-core/src/index.ts

···
 export { fromRef, fromRefs, isRef, ref, refs } from './refs/refs';
 export type { FromRef, FromRefs, Ref, Refs } from './refs/types';
 export type { RenderContext, Renderer } from './renderer';
+export { StructureModel } from './structure/model';
+export { StructureNode } from './structure/node';
+export type {
+  StructureInsert,
+  StructureItem,
+  StructureLocation,
+  StructureShell,
+  StructureShellResult,
+} from './structure/types';
 export { Symbol } from './symbols/symbol';
 export type {
   BindingKind,

packages/codegen-core/src/structure/model.ts

···
+import { StructureNode } from './node';
+import type { StructureInsert } from './types';
+
+export class StructureModel {
+  /** Root nodes mapped by their names. */
+  private _roots: Map<string, StructureNode> = new Map();
+  /** Node for data without a specific root. */
+  private _virtualRoot?: StructureNode;
+
+  /**
+   * Get all root nodes.
+   */
+  get roots(): ReadonlyArray<StructureNode> {
+    const roots = Array.from(this._roots.values());
+    if (this._virtualRoot) roots.unshift(this._virtualRoot);
+    return roots;
+  }
+
+  /**
+   * Insert data into the structure.
+   */
+  insert(args: StructureInsert): void {
+    const { data, locations, source } = args;
+    for (const location of locations) {
+      const { path, shell } = location;
+      const fullPath = path.filter((s): s is string => Boolean(s));
+      const segments = fullPath.slice(0, -1);
+      const name = fullPath[fullPath.length - 1];
+
+      if (!name) {
+        throw new Error('Cannot insert data without path.');
+      }
+
+      let cursor: StructureNode | null = null;
+
+      for (const segment of segments) {
+        if (!cursor) {
+          cursor = this.root(segment);
+        } else {
+          cursor = cursor.child(segment);
+        }
+
+        if (shell && !cursor.shell) {
+          cursor.shell = shell;
+          cursor.shellSource = source;
+        }
+      }
+
+      if (!cursor) {
+        cursor = this.root(null);
+      }
+
+      cursor.items.push({ data, location: fullPath, source });
+    }
+  }
+
+  /**
+   * Gets or creates a root by name.
+   *
+   * If the root doesn't exist, it's created automatically.
+   *
+   * @param name - The name of the root
+   * @returns The root instance
+   */
+  root(name: string | null): StructureNode {
+    if (!name) {
+      return (this._virtualRoot ??= new StructureNode('', undefined, {
+        virtual: true,
+      }));
+    }
+    if (!this._roots.has(name)) {
+      this._roots.set(name, new StructureNode(name));
+    }
+    return this._roots.get(name)!;
+  }
+
+  /**
+   * Walk all nodes in the structure (depth-first, post-order).
+   *
+   * @returns Generator of all structure nodes
+   */
+  *walk(): Generator<StructureNode> {
+    if (this._virtualRoot) {
+      yield* this._virtualRoot.walk();
+    }
+    for (const root of this._roots.values()) {
+      yield* root.walk();
+    }
+  }
+}

packages/codegen-core/src/structure/node.ts

···
+import type { StructureItem, StructureShell } from './types';
+
+export class StructureNode {
+  /** Nested nodes within this node. */
+  children: Map<string, StructureNode> = new Map();
+  /** Items contained in this node. */
+  items: Array<StructureItem> = [];
+  /** The name of this node (e.g., "Users", "Accounts"). */
+  name: string;
+  /** Parent node in the hierarchy. Undefined if this is the root node. */
+  parent?: StructureNode;
+  /** Shell claimed for this node. */
+  shell?: StructureShell;
+  /** Source of the claimed shell. */
+  shellSource?: symbol;
+  /** True if this is a virtual root. */
+  virtual: boolean;
+
+  constructor(
+    name: string,
+    parent?: StructureNode,
+    options?: {
+      virtual?: boolean;
+    },
+  ) {
+    this.name = name;
+    this.parent = parent;
+    this.virtual = options?.virtual ?? false;
+  }
+
+  get isRoot(): boolean {
+    return !this.parent;
+  }
+
+  /**
+   * Gets or creates a child node.
+   *
+   * If the child doesn't exist, it's created automatically.
+   *
+   * @param name - The name of the child node
+   * @returns The child node instance
+   */
+  child(name: string): StructureNode {
+    if (!this.children.has(name)) {
+      this.children.set(name, new StructureNode(name, this));
+    }
+    return this.children.get(name)!;
+  }
+
+  /**
+   * Gets the full path of this node in the hierarchy.
+   *
+   * @returns An array of node names from the root to this node
+   */
+  getPath(): ReadonlyArray<string> {
+    const path: Array<string> = [];
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let cursor: StructureNode | undefined = this;
+    while (cursor) {
+      path.unshift(cursor.name);
+      cursor = cursor.parent;
+    }
+    return path;
+  }
+
+  /**
+   * Yields items from a specific source with typed data.
+   *
+   * @param source - The source symbol to filter by
+   * @returns Generator of items from that source
+   */
+  *itemsFrom<T = unknown>(
+    source: symbol,
+  ): Generator<StructureItem & { data: T }> {
+    for (const item of this.items) {
+      if (item.source === source) {
+        yield item as StructureItem & { data: T };
+      }
+    }
+  }
+
+  /**
+   * Walk all nodes in the structure (depth-first, post-order).
+   *
+   * @returns Generator of all structure nodes
+   */
+  *walk(): Generator<StructureNode> {
+    for (const node of this.children.values()) {
+      yield* node.walk();
+    }
+    yield this;
+  }
+}

packages/codegen-core/src/structure/types.d.ts

···
+import type { INode } from '../nodes/node';
+import type { StructureNode } from './node';
+
+export interface StructureInsert {
+  /** Inserted data. */
+  data: unknown;
+  /** Locations where the data should be inserted. */
+  locations: ReadonlyArray<StructureLocation>;
+  /** Source of the inserted data. */
+  source: symbol;
+}
+
+export interface StructureItem
+  extends Pick<StructureInsert, 'data' | 'source'> {
+  /** Location of this item within the structure. */
+  location: ReadonlyArray<string>;
+}
+
+export interface StructureLocation {
+  /** Path within the structure where the data should be inserted. */
+  path: ReadonlyArray<string>;
+  /** Shell to apply at this location. */
+  shell?: StructureShell;
+}
+
+export interface StructureShell {
+  define: (node: StructureNode) => StructureShellResult;
+}
+
+export interface StructureShellResult {
+  dependencies?: Array<INode>;
+  node: INode;
+}

packages/openapi-ts/src/ir/context.ts

···
 import type { Package } from '~/config/utils/package';
 import { packageFactory } from '~/config/utils/package';
 import type { Graph } from '~/graph';
-import { buildName } from '~/openApi/shared/utils/name';
 import type { PluginConfigMap } from '~/plugins/config';
 import { PluginInstance } from '~/plugins/shared/utils/instance';
 import type { PluginNames } from '~/plugins/types';
 import { TypeScriptRenderer } from '~/ts-dsl';
 import type { Config } from '~/types/config';
 import type { Logger } from '~/utils/logger';
+import { applyNaming } from '~/utils/naming';
 import { resolveRef } from '~/utils/ref';
 
 import type { IR } from './types';
···
     this.gen = new Project({
       defaultFileName: 'index',
       fileName: (base) => {
-        const name = buildName({
-          config: config.output.fileName,
-          name: base,
-        });
+        const name = applyNaming(base, config.output.fileName);
         const { suffix } = config.output.fileName;
         if (!suffix) {
           return name;

packages/openapi-ts/src/openApi/shared/locations/index.ts

···
+export type {
+  OperationLocationStrategy,
+  OperationPathStrategy,
+} from './operation';
+export { OperationLocations, OperationPath } from './operation';

packages/openapi-ts/src/openApi/shared/locations/operation.ts

···
+import type { StructureLocation, StructureShell } from '@hey-api/codegen-core';
+
+import type { IR } from '~/ir/types';
+
+/**
+ * A function that determines where an operation appears in the structure.
+ *
+ * Returns one or more locations, each with a full path and optional shell.
+ */
+export type OperationLocationStrategy = (
+  operation: IR.OperationObject,
+) => ReadonlyArray<StructureLocation>;
+
+/**
+ * A function that derives path segments from an operation.
+ *
+ * Used by location strategies to build paths within containers.
+ */
+export type OperationPathStrategy = (
+  operation: IR.OperationObject,
+) => ReadonlyArray<string>;
+
+/**
+ * Built-in location strategies for operations.
+ */
+export const OperationLocations = {
+  /**
+   * Creates one root container per operation tag.
+   *
+   * Operations with multiple tags appear in multiple root containers.
+   * Operations without tags use the fallback root container.
+   *
+   * @example
+   * // Operation with tags: ['users', 'admin']
+   * // Path function returns: ['list']
+   * // Result: [{ path: ['users', 'list'], shell }, { path: ['admin', 'list'], shell }]
+   */
+  byTags:
+    (config: {
+      /**
+       * Root name for operations without tags.
+       *
+       * @default 'default'
+       */
+      fallback?: string;
+      /**
+       * Derives path segments from the operation.
+       *
+       * @default OperationPath.fromOperationId()
+       */
+      path?: OperationPathStrategy;
+      /**
+       * Shell to apply to all created nodes.
+       */
+      shell: StructureShell;
+    }): OperationLocationStrategy =>
+    (operation) => {
+      const tags =
+        operation.tags && operation.tags.length > 0
+          ? operation.tags
+          : [config.fallback ?? 'default'];
+      const pathSegments = (config.path ?? OperationPath.fromOperationId())(
+        operation,
+      );
+      return tags.map((tag) => ({
+        path: [tag, ...pathSegments],
+        shell: config.shell,
+      }));
+    },
+
+  /**
+   * Creates flat functions without any container.
+   *
+   * Each operation becomes a standalone function at the root level.
+   * No shell is applied.
+   *
+   * @example
+   * // Operation id: 'getUsers'
+   * // Result: [{ path: ['getUsers'] }]
+   */
+  flat:
+    (config?: {
+      /**
+       * Derives the function name from the operation.
+       *
+       * @default operation.id
+       */
+      name?: (operation: IR.OperationObject) => string;
+    }): OperationLocationStrategy =>
+    (operation) => [
+      {
+        path: [(config?.name ?? ((operation) => operation.id))(operation)],
+      },
+    ],
+
+  /**
+   * Places all operations under a single root container.
+   *
+   * @example
+   * // Root: 'Sdk', path function returns: ['users', 'list']
+   * // Result: [{ path: ['Sdk', 'users', 'list'], shell }]
+   */
+  single:
+    (config: {
+      /**
+       * Derives path segments within the root from the operation.
+       *
+       * @default OperationPath.fromOperationId()
+       */
+      path?: OperationPathStrategy;
+      /**
+       * Name of the container.
+       */
+      root: string;
+      /**
+       * Shell to apply to all created nodes.
+       */
+      shell: StructureShell;
+    }): OperationLocationStrategy =>
+    (operation) => [
+      {
+        path: [
+          config.root,
+          ...(config.path ?? OperationPath.fromOperationId())(operation),
+        ],
+        shell: config.shell,
+      },
+    ],
+};
+
+/**
+ * Built-in path derivation helpers for operations.
+ */
+export const OperationPath = {
+  /**
+   * Splits operationId by delimiters to create nested paths.
+   *
+   * The last segment is converted to camelCase.
+   * Falls back to operation.id if operationId is missing.
+   *
+   * @example
+   * // operationId: 'users.accounts.list'
+   * // Result: ['users', 'accounts', 'list']
+   *
+   * @example
+   * // operationId: 'users/accounts/getAll'
+   * // Result: ['users', 'accounts', 'getAll']
+   */
+  fromOperationId:
+    (config?: {
+      /**
+       * Pattern to split operationId.
+       *
+       * @default /[./]/
+       */
+      delimiters: RegExp;
+    }): OperationPathStrategy =>
+    (operation) => {
+      if (!operation.operationId) return [operation.id];
+      const segments = operation.operationId
+        .split(config?.delimiters ?? /[./]/)
+        .filter(Boolean);
+      return segments.length > 0 ? segments : [operation.id];
+    },
+
+  /**
+   * Uses operation.id as a single path segment.
+   *
+   * @example
+   * // operation.id: 'getUserById'
+   * // Result: ['getUserById']
+   */
+  id: (): OperationPathStrategy => (operation) => [operation.id],
+};

packages/openapi-ts/src/openApi/shared/transforms/enums.ts

···
+import { applyNaming } from '~/utils/naming';
 import { jsonPointerToPath } from '~/utils/ref';
 
 import type { Config } from '../../../types/config';
-import { buildName } from '../utils/name';
 import { deepClone } from '../utils/schema';
 import { childSchemaRelationships } from '../utils/schemaChildRelationships';
 import { getSchemasObject } from '../utils/transforms';
···
     }
 
     // Generate a unique name for the new root enum using config
-    const base = buildName({
-      config,
-      name:
-        typeof node === 'object' &&
+    const base = applyNaming(
+      typeof node === 'object' &&
         node &&
         'title' in node &&
         typeof node.title === 'string'
-          ? node.title
-          : String(key),
-    });
+        ? node.title
+        : String(key),
+      config,
+    );
     const name = getUniqueComponentName({
       base,
       components: schemasObj,

packages/openapi-ts/src/openApi/shared/transforms/readWrite.ts

···
 import type { Graph } from '~/graph';
 import type { Logger } from '~/utils/logger';
+import { applyNaming } from '~/utils/naming';
 import { jsonPointerToPath } from '~/utils/ref';
 
 import type { Config } from '../../../types/config';
 import deepEqual from '../utils/deepEqual';
 import { buildGraph, type Scope } from '../utils/graph';
-import { buildName } from '../utils/name';
 import { deepClone } from '../utils/schema';
 import { childSchemaRelationships } from '../utils/schemaChildRelationships';
 import {
···
     // read variant
     const readSchema = deepClone<unknown>(nodeInfo.node);
     pruneSchemaByScope(graph, readSchema, 'writeOnly');
-    const readBase = buildName({
-      config: config.responses,
-      name,
-    });
+    const readBase = applyNaming(name, config.responses);
     const readName =
       readBase === name
         ? readBase
···
     ) {
       continue;
     }
-    const writeBase = buildName({
-      config: config.requests,
-      name,
-    });
+    const writeBase = applyNaming(name, config.requests);
     const writeName =
       writeBase === name && writeBase !== readName
         ? writeBase

packages/openapi-ts/src/openApi/shared/utils/name.ts

···
-import type { StringCase, StringName } from '~/types/case';
-import { toCase } from '~/utils/to-case';
-
-export const buildName = ({
-  config,
-  name,
-}: {
-  config: {
-    case: StringCase;
-    name?: StringName;
-  };
-  name: string;
-}): string => {
-  if (typeof config.name === 'function') {
-    name = config.name(name);
-  } else if (config.name) {
-    const separator = config.case === 'preserve' ? '' : '-';
-    name = config.name.replace('{{name}}', `${separator}${name}${separator}`);
-  }
-
-  return toCase(name, config.case);
-};

packages/openapi-ts/src/openApi/shared/utils/operation.ts

···
 import type { Context } from '~/ir/context';
 import { createOperationKey } from '~/ir/operation';
 import { sanitizeNamespaceIdentifier } from '~/openApi/common/parser/sanitize';
-import { toCase } from '~/utils/to-case';
+import { toCase } from '~/utils/naming';
 
 import type { State } from '../types/state';
 

packages/openapi-ts/src/plugins/@angular/common/config.ts

···
     if (!plugin.config.httpRequests.methodNameBuilder) {
       const { asClass } = plugin.config.httpRequests;
       plugin.config.httpRequests.methodNameBuilder = (operation) =>
-        asClass ? String(operation.id) : `${String(operation.id)}Request`;
+        asClass ? `${operation.id}` : `${operation.id}Request`;
     }
 
     plugin.config.httpResources = context.valueToObject({
···
     if (!plugin.config.httpResources.methodNameBuilder) {
       const { asClass } = plugin.config.httpResources;
       plugin.config.httpResources.methodNameBuilder = (operation) =>
-        asClass ? String(operation.id) : `${String(operation.id)}Resource`;
+        asClass ? `${operation.id}` : `${operation.id}Resource`;
     }
   },
 };

packages/openapi-ts/src/plugins/@angular/common/httpRequests.ts

···
-import type { Symbol } from '@hey-api/codegen-core';
-
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { operationClasses } from '~/plugins/@hey-api/sdk/shared/operation';
 import {
   createOperationComment,
   isOperationOptionsRequired,
 } from '~/plugins/shared/utils/operation';
 import { $ } from '~/ts-dsl';
-import { toCase } from '~/utils/to-case';
+import { applyNaming, toCase } from '~/utils/naming';
 
 import type { AngularCommonPlugin } from './types';
 
···
   root: boolean;
 }
 
-const generateAngularClassRequests = ({
+const generateClassRequests = ({
   plugin,
 }: {
   plugin: AngularCommonPlugin['Instance'];
···
   const requestClasses = new Map<string, AngularRequestClassEntry>();
   const generatedClasses = new Set<string>();
 
+  const symbolHttpRequest = plugin.referenceSymbol({
+    category: 'external',
+    resource: '@angular/common/http.HttpRequest',
+  });
+  const symbolOptions = plugin.referenceSymbol({
+    category: 'type',
+    resource: 'client-options',
+    tool: 'sdk',
+  });
+  const symbolInjectable = plugin.referenceSymbol({
+    category: 'external',
+    resource: '@angular/core.Injectable',
+  });
+
   const sdkPlugin = plugin.getPluginOrThrow('@hey-api/sdk');
 
   plugin.forEach(
···
             return;
           }
 
-          const methodNode = generateAngularRequestMethod({
-            isRequiredOptions,
-            methodName: requestMethodName,
-            operation,
-            plugin,
+          const symbolDataType = plugin.querySymbol({
+            category: 'type',
+            resource: 'operation',
+            resourceId: operation.id,
+            role: 'data',
+            tool: 'typescript',
           });
 
+          const methodNode = $.method(requestMethodName)
+            .public()
+            .$if(createOperationComment(operation), (c, v) => c.doc(v))
+            .param('options', (p) =>
+              p.required(isRequiredOptions).type(
+                $.type(symbolOptions)
+                  .generic(symbolDataType ?? 'unknown')
+                  .generic('ThrowOnError'),
+              ),
+            )
+            .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
+            .returns($.type(symbolHttpRequest).generic('unknown'))
+            .do(
+              $.return(
+                generateRequestCallExpression({
+                  operation,
+                  plugin,
+                }),
+              ),
+            );
+
           if (!currentClass.nodes.length) {
             currentClass.nodes.push(methodNode);
           } else {
···
         currentClass.nodes.push(
           $.field(toCase(childClass.className, 'camelCase')).assign(
             $.new(
-              buildName({
-                config: {
-                  case: 'preserve',
-                  name: plugin.config.httpRequests.classNameBuilder,
-                },
-                name: childClass.className,
+              applyNaming(childClass.className, {
+                case: 'preserve',
+                name: plugin.config.httpRequests.classNameBuilder,
               }),
             ),
           ),
···
       }
     }
 
-    const symbolInjectable = plugin.referenceSymbol({
-      category: 'external',
-      resource: '@angular/core.Injectable',
-    });
-    const symbolClass = plugin.registerSymbol({
-      meta: {
-        category: 'utility',
-        resource: 'class',
-        resourceId: currentClass.className,
-        tool: 'angular',
-      },
-      name: buildName({
-        config: {
-          case: 'preserve',
-          name: plugin.config.httpRequests.classNameBuilder,
-        },
-        name: currentClass.className,
+    const symbolClass = plugin.symbol(
+      applyNaming(currentClass.className, {
+        case: 'preserve',
+        name: plugin.config.httpRequests.classNameBuilder,
       }),
-    });
+      {
+        meta: {
+          category: 'utility',
+          resource: 'class',
+          resourceId: currentClass.className,
+          tool: 'angular',
+        },
+      },
+    );
     const node = $.class(symbolClass)
       .export()
       .$if(currentClass.root, (c) =>
···
   }
 };
 
-const generateAngularFunctionRequests = ({
+const generateFunctionRequests = ({
   plugin,
 }: {
   plugin: AngularCommonPlugin['Instance'];
 }) => {
+  const symbolHttpRequest = plugin.referenceSymbol({
+    category: 'external',
+    resource: '@angular/common/http.HttpRequest',
+  });
+  const symbolOptions = plugin.referenceSymbol({
+    category: 'type',
+    resource: 'client-options',
+    tool: 'sdk',
+  });
+
   plugin.forEach(
     'operation',
     ({ operation }) => {
···
         operation,
       });
 
-      const symbol = plugin.registerSymbol({
-        meta: {
-          category: 'utility',
-          resource: 'operation',
-          resourceId: operation.id,
-          role: 'data',
-          tool: 'angular',
+      const symbol = plugin.symbol(
+        plugin.config.httpRequests.methodNameBuilder(operation),
+        {
+          meta: {
+            category: 'utility',
+            resource: 'operation',
+            resourceId: operation.id,
+            role: 'data',
+            tool: 'angular',
+          },
         },
-        name: plugin.config.httpRequests.methodNameBuilder(operation),
-      });
-      const node = generateAngularRequestFunction({
-        isRequiredOptions,
-        operation,
-        plugin,
-        symbol,
+      );
+
+      const symbolDataType = plugin.querySymbol({
+        category: 'type',
+        resource: 'operation',
+        resourceId: operation.id,
+        role: 'data',
+        tool: 'typescript',
       });
+
+      const node = $.const(symbol)
+        .export()
+        .$if(createOperationComment(operation), (c, v) => c.doc(v))
+        .assign(
+          $.func()
+            .param('options', (p) =>
+              p.required(isRequiredOptions).type(
+                $.type(symbolOptions)
+                  .generic(symbolDataType ?? 'unknown')
+                  .generic('ThrowOnError'),
+              ),
+            )
+            .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
+            .returns($.type(symbolHttpRequest).generic('unknown'))
+            .do(
+              $.return(
+                generateRequestCallExpression({
+                  operation,
+                  plugin,
+                }),
+              ),
+            ),
+        );
       plugin.node(node);
     },
     {
···
     );
 };
 
-const generateAngularRequestMethod = ({
-  isRequiredOptions,
-  methodName,
-  operation,
-  plugin,
-}: {
-  isRequiredOptions: boolean;
-  methodName: string;
-  operation: IR.OperationObject;
-  plugin: AngularCommonPlugin['Instance'];
-}) => {
-  const symbolHttpRequest = plugin.referenceSymbol({
-    category: 'external',
-    resource: '@angular/common/http.HttpRequest',
-  });
-
-  const symbolOptions = plugin.referenceSymbol({
-    category: 'type',
-    resource: 'client-options',
-    tool: 'sdk',
-  });
-
-  const symbolDataType = plugin.querySymbol({
-    category: 'type',
-    resource: 'operation',
-    resourceId: operation.id,
-    role: 'data',
-    tool: 'typescript',
-  });
-
-  return $.method(methodName)
-    .public()
-    .$if(createOperationComment(operation), (c, v) => c.doc(v))
-    .param('options', (p) =>
-      p.required(isRequiredOptions).type(
-        $.type(symbolOptions)
-          .generic(symbolDataType ?? 'unknown')
-          .generic('ThrowOnError'),
-      ),
-    )
-    .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
-    .returns($.type(symbolHttpRequest).generic('unknown'))
-    .do(
-      $.return(
-        generateRequestCallExpression({
-          operation,
-          plugin,
-        }),
-      ),
-    );
-};
-
-const generateAngularRequestFunction = ({
-  isRequiredOptions,
-  operation,
-  plugin,
-  symbol,
-}: {
-  isRequiredOptions: boolean;
-  operation: IR.OperationObject;
-  plugin: AngularCommonPlugin['Instance'];
-  symbol: Symbol;
-}) => {
-  const symbolHttpRequest = plugin.referenceSymbol({
-    category: 'external',
-    resource: '@angular/common/http.HttpRequest',
-  });
-
-  const symbolOptions = plugin.referenceSymbol({
-    category: 'type',
-    resource: 'client-options',
-    tool: 'sdk',
-  });
-
-  const symbolDataType = plugin.querySymbol({
-    category: 'type',
-    resource: 'operation',
-    resourceId: operation.id,
-    role: 'data',
-    tool: 'typescript',
-  });
-
-  return $.const(symbol)
-    .export()
-    .$if(createOperationComment(operation), (c, v) => c.doc(v))
-    .assign(
-      $.func()
-        .param('options', (p) =>
-          p.required(isRequiredOptions).type(
-            $.type(symbolOptions)
-              .generic(symbolDataType ?? 'unknown')
-              .generic('ThrowOnError'),
-          ),
-        )
-        .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
-        .returns($.type(symbolHttpRequest).generic('unknown'))
-        .do(
-          $.return(
-            generateRequestCallExpression({
-              operation,
-              plugin,
-            }),
-          ),
-        ),
-    );
-};
-
 export const createHttpRequests: AngularCommonPlugin['Handler'] = ({
   plugin,
 }) => {
   if (plugin.config.httpRequests.asClass) {
-    generateAngularClassRequests({ plugin });
+    generateClassRequests({ plugin });
   } else {
-    generateAngularFunctionRequests({ plugin });
+    generateFunctionRequests({ plugin });
   }
 };

packages/openapi-ts/src/plugins/@angular/common/httpResources.ts

···
-import type { Symbol } from '@hey-api/codegen-core';
-
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { operationClasses } from '~/plugins/@hey-api/sdk/shared/operation';
 import {
   createOperationComment,
   isOperationOptionsRequired,
 } from '~/plugins/shared/utils/operation';
 import { $ } from '~/ts-dsl';
-import { toCase } from '~/utils/to-case';
+import { applyNaming, toCase } from '~/utils/naming';
 
 import type { AngularCommonPlugin } from './types';
 
···
   root: boolean;
 }
 
-const generateAngularClassServices = ({
+const generateClassServices = ({
   plugin,
 }: {
   plugin: AngularCommonPlugin['Instance'];
···
   const serviceClasses = new Map<string, AngularServiceClassEntry>();
   const generatedClasses = new Set<string>();
 
+  const symbolInjectable = plugin.referenceSymbol({
+    category: 'external',
+    resource: '@angular/core.Injectable',
+  });
+  const symbolOptions = plugin.referenceSymbol({
+    category: 'type',
+    resource: 'client-options',
+    tool: 'sdk',
+  });
+
   const sdkPlugin = plugin.getPluginOrThrow('@hey-api/sdk');
 
   plugin.forEach(
···
             return;
           }
 
-          const methodNode = generateAngularResourceMethod({
-            isRequiredOptions,
-            methodName: resourceMethodName,
-            operation,
-            plugin,
+          const symbolDataType = plugin.querySymbol({
+            category: 'type',
+            resource: 'operation',
+            resourceId: operation.id,
+            role: 'data',
+            tool: 'typescript',
           });
 
+          const methodNode = $.method(resourceMethodName)
+            .public()
+            .$if(createOperationComment(operation), (c, v) => c.doc(v))
+            .param('options', (p) =>
+              p.required(isRequiredOptions).type(
+                $.type.func().returns(
+                  $.type.or(
+                    $.type(symbolOptions)
+                      .generic(symbolDataType ?? 'unknown')
+                      .generic('ThrowOnError'),
+                    $.type('undefined'),
+                  ),
+                ),
+              ),
+            )
+            .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
+            .do(
+              $.return(
+                generateResourceCallExpression({
+                  operation,
+                  plugin,
+                }),
+              ),
+            );
+
           if (!currentClass.nodes.length) {
             currentClass.nodes.push(methodNode);
           } else {
···
         currentClass.nodes.push(
           $.field(toCase(childClass.className, 'camelCase')).assign(
             $.new(
-              buildName({
-                config: {
-                  case: 'preserve',
-                  name: plugin.config.httpResources.classNameBuilder,
-                },
-                name: childClass.className,
+              applyNaming(childClass.className, {
+                case: 'preserve',
+                name: plugin.config.httpResources.classNameBuilder,
               }),
             ),
           ),
···
       }
     }
 
-    const symbolInjectable = plugin.referenceSymbol({
-      category: 'external',
-      resource: '@angular/core.Injectable',
-    });
-    const symbolClass = plugin.registerSymbol({
-      name: buildName({
-        config: {
-          case: 'preserve',
-          name: plugin.config.httpResources.classNameBuilder,
-        },
-        name: currentClass.className,
+    const symbolClass = plugin.symbol(
+      applyNaming(currentClass.className, {
+        case: 'preserve',
+        name: plugin.config.httpResources.classNameBuilder,
       }),
-    });
+    );
     const node = $.class(symbolClass)
       .export()
       .$if(currentClass.root, (c) =>
···
   }
 };
 
-const generateAngularFunctionServices = ({
+const generateFunctionServices = ({
   plugin,
 }: {
   plugin: AngularCommonPlugin['Instance'];
 }) => {
+  const symbolOptions = plugin.referenceSymbol({
+    category: 'type',
+    resource: 'client-options',
+    tool: 'sdk',
+  });
+
   plugin.forEach(
     'operation',
     ({ operation }) => {
···
         operation,
       });
 
-      const symbol = plugin.registerSymbol({
-        name: plugin.config.httpResources.methodNameBuilder(operation),
-      });
-      const node = generateAngularResourceFunction({
-        isRequiredOptions,
-        operation,
-        plugin,
-        symbol,
+      const symbol = plugin.symbol(
+        plugin.config.httpResources.methodNameBuilder(operation),
+      );
+
+      const symbolDataType = plugin.querySymbol({
+        category: 'type',
+        resource: 'operation',
+        resourceId: operation.id,
+        role: 'data',
+        tool: 'typescript',
       });
+
+      const node = $.const(symbol)
+        .export()
+        .$if(createOperationComment(operation), (c, v) => c.doc(v))
+        .assign(
+          $.func()
+            .param('options', (p) =>
+              p.required(isRequiredOptions).type(
+                $.type.func().returns(
+                  $.type.or(
+                    $.type(symbolOptions)
+                      .generic(symbolDataType ?? 'unknown')
+                      .generic('ThrowOnError'),
+                    $.type('undefined'),
+                  ),
+                ),
+              ),
+            )
+            .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
+            .do(
+              $.return(
+                generateResourceCallExpression({
+                  operation,
+                  plugin,
+                }),
+              ),
+            ),
+        );
       plugin.node(node);
     },
     {
···
     category: 'external',
     resource: '@angular/common/http.httpResource',
   });
+  const symbolInject = plugin.referenceSymbol({
+    category: 'external',
+    resource: '@angular/core.inject',
+  });
 
   const symbolResponseType = plugin.querySymbol({
     category: 'type',
···
       });
 
       // Build the method access path using inject
-      const symbolInject = plugin.referenceSymbol({
-        category: 'external',
-        resource: '@angular/core.inject',
-      });
       let methodAccess: ReturnType<typeof $.attr | typeof $.call> =
         $(symbolInject).call(symbolClass);
 
···
   );
 };
 
-const generateAngularResourceMethod = ({
-  isRequiredOptions,
-  methodName,
-  operation,
-  plugin,
-}: {
-  isRequiredOptions: boolean;
-  methodName: string;
-  operation: IR.OperationObject;
-  plugin: AngularCommonPlugin['Instance'];
-}) => {
-  const symbolOptions = plugin.referenceSymbol({
-    category: 'type',
-    resource: 'client-options',
-    tool: 'sdk',
-  });
-
-  const symbolDataType = plugin.querySymbol({
-    category: 'type',
-    resource: 'operation',
-    resourceId: operation.id,
-    role: 'data',
-    tool: 'typescript',
-  });
-
-  return $.method(methodName)
-    .public()
-    .$if(createOperationComment(operation), (c, v) => c.doc(v))
-    .param('options', (p) =>
-      p.required(isRequiredOptions).type(
-        $.type.func().returns(
-          $.type.or(
-            $.type(symbolOptions)
-              .generic(symbolDataType ?? 'unknown')
-              .generic('ThrowOnError'),
-            $.type('undefined'),
-          ),
-        ),
-      ),
-    )
-    .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
-    .do(
-      $.return(
-        generateResourceCallExpression({
-          operation,
-          plugin,
-        }),
-      ),
-    );
-};
-
-const generateAngularResourceFunction = ({
-  isRequiredOptions,
-  operation,
-  plugin,
-  symbol,
-}: {
-  isRequiredOptions: boolean;
-  operation: IR.OperationObject;
-  plugin: AngularCommonPlugin['Instance'];
-  symbol: Symbol;
-}) => {
-  const symbolOptions = plugin.referenceSymbol({
-    category: 'type',
-    resource: 'client-options',
-    tool: 'sdk',
-  });
-
-  const symbolDataType = plugin.querySymbol({
-    category: 'type',
-    resource: 'operation',
-    resourceId: operation.id,
-    role: 'data',
-    tool: 'typescript',
-  });
-
-  return $.const(symbol)
-    .export()
-    .$if(createOperationComment(operation), (c, v) => c.doc(v))
-    .assign(
-      $.func()
-        .param('options', (p) =>
-          p.required(isRequiredOptions).type(
-            $.type.func().returns(
-              $.type.or(
-                $.type(symbolOptions)
-                  .generic(symbolDataType ?? 'unknown')
-                  .generic('ThrowOnError'),
-                $.type('undefined'),
-              ),
-            ),
-          ),
-        )
-        .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
-        .do(
-          $.return(
-            generateResourceCallExpression({
-              operation,
-              plugin,
-            }),
-          ),
-        ),
-    );
-};
-
 export const createHttpResources: AngularCommonPlugin['Handler'] = ({
   plugin,
 }) => {
   if (plugin.config.httpResources.asClass) {
-    generateAngularClassServices({ plugin });
+    generateClassServices({ plugin });
   } else {
-    generateAngularFunctionServices({ plugin });
+    generateFunctionServices({ plugin });
   }
 };

packages/openapi-ts/src/plugins/@angular/common/plugin.ts

···
 import type { AngularCommonPlugin } from './types';
 
 export const handler: AngularCommonPlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('HttpRequest', {
     external: '@angular/common/http',
     kind: 'type',
     meta: {
       category: 'external',
       resource: '@angular/common/http.HttpRequest',
     },
-    name: 'HttpRequest',
   });
-  plugin.registerSymbol({
+  plugin.symbol('inject', {
     external: '@angular/core',
     meta: {
       category: 'external',
       resource: '@angular/core.inject',
     },
-    name: 'inject',
   });
-  plugin.registerSymbol({
+  plugin.symbol('Injectable', {
     external: '@angular/core',
     meta: {
       category: 'external',
       resource: '@angular/core.Injectable',
     },
-    name: 'Injectable',
   });
-  plugin.registerSymbol({
+  plugin.symbol('httpResource', {
     external: '@angular/common/http',
     meta: {
       category: 'external',
       resource: '@angular/common/http.httpResource',
     },
-    name: 'httpResource',
   });
 
   if (plugin.config.httpRequests.enabled) {

packages/openapi-ts/src/plugins/@angular/common/types.d.ts

···
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringName } from '~/types/case';
+import type { NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'@angular/common'> &
   Plugin.Hooks & {
···
            * Builds the class name for the generated resource.
            * By default, the class name is suffixed with "Resources".
            */
-          classNameBuilder?: StringName;
+          classNameBuilder?: NameTransformer;
           /**
            * Whether or not to create HTTP Request instances.
            *
···
            * Builds the class name for the generated resource.
            * By default, the class name is suffixed with "Resources".
            */
-          classNameBuilder?: StringName;
+          classNameBuilder?: NameTransformer;
           /**
            * Whether or not to create HTTP resource APIs.
            *
···
        * Builds the class name for the generated resource.
        * By default, the class name is suffixed with "Resources".
        */
-      classNameBuilder: StringName;
+      classNameBuilder: NameTransformer;
       /**
        * Whether or not to create HTTP Request instances.
        *
···
        * Builds the class name for the generated resource.
        * By default, the class name is suffixed with "Resources".
        */
-      classNameBuilder: StringName;
+      classNameBuilder: NameTransformer;
       /**
        * Whether or not to create HTTP resource APIs.
        *

packages/openapi-ts/src/plugins/@hey-api/client-core/client.ts

···
 
 export const createClient: PluginHandler = ({ plugin }) => {
   const clientModule = clientFolderAbsolutePath(plugin.context.config);
-  const symbolCreateClient = plugin.registerSymbol({
+  const symbolCreateClient = plugin.symbol('createClient', {
     external: clientModule,
-    name: 'createClient',
   });
-  const symbolCreateConfig = plugin.registerSymbol({
+  const symbolCreateConfig = plugin.symbol('createConfig', {
     external: clientModule,
-    name: 'createConfig',
   });
   const symbolClientOptions = plugin.referenceSymbol({
     category: 'type',
···
 
   const { runtimeConfigPath } = plugin.config;
   const symbolCreateClientConfig = runtimeConfigPath
-    ? plugin.registerSymbol({
+    ? plugin.symbol('createClientConfig', {
         external: runtimeConfigPath,
-        name: 'createClientConfig',
       })
     : undefined;
 
···
       .generic(symbolClientOptions),
   ];
 
-  const symbolClient = plugin.registerSymbol({
+  const symbolClient = plugin.symbol('client', {
     meta: {
       category: 'client',
     },
-    name: 'client',
   });
   const statement = $.const(symbolClient)
     .export()

packages/openapi-ts/src/plugins/@hey-api/client-core/createClientConfig.ts

···
     resource: 'client',
     role: 'options',
   });
-  const symbolConfig = plugin.registerSymbol({
+  const symbolConfig = plugin.symbol('Config', {
     external: clientModule,
     kind: 'type',
-    name: 'Config',
   });
-  const symbolDefaultClientOptions = plugin.registerSymbol({
+  const symbolDefaultClientOptions = plugin.symbol('ClientOptions', {
     external: clientModule,
     kind: 'type',
-    name: 'ClientOptions',
   });
-  const symbolCreateClientConfig = plugin.registerSymbol({
-    name: 'CreateClientConfig',
-  });
+  const symbolCreateClientConfig = plugin.symbol('CreateClientConfig');
 
   const typeCreateClientConfig = $.type
     .alias(symbolCreateClientConfig)

packages/openapi-ts/src/plugins/@hey-api/schemas/plugin.ts

···
 
   for (const name in context.spec.definitions) {
     const schema = context.spec.definitions[name]!;
-    const symbol = plugin.registerSymbol({
+    const symbol = plugin.symbol(schemaName({ name, plugin, schema }), {
       meta: {
         category: 'schema',
         resource: 'definition',
         resourceId: name,
         tool: 'json-schema',
       },
-      name: schemaName({ name, plugin, schema }),
     });
     const obj = schemaToJsonSchemaDraft_04({
       context,
···
 
   for (const name in context.spec.components.schemas) {
     const schema = context.spec.components.schemas[name]!;
-    const symbol = plugin.registerSymbol({
+    const symbol = plugin.symbol(schemaName({ name, plugin, schema }), {
       meta: {
         category: 'schema',
         resource: 'definition',
         resourceId: name,
         tool: 'json-schema',
       },
-      name: schemaName({ name, plugin, schema }),
     });
     const obj = schemaToJsonSchemaDraft_05({
       context,
···
 
   for (const name in context.spec.components.schemas) {
     const schema = context.spec.components.schemas[name]!;
-    const symbol = plugin.registerSymbol({
+    const symbol = plugin.symbol(schemaName({ name, plugin, schema }), {
       meta: {
         category: 'schema',
         resource: 'definition',
         resourceId: name,
         tool: 'json-schema',
       },
-      name: schemaName({ name, plugin, schema }),
     });
     const obj = schemaToJsonSchema2020_12({
       context,

packages/openapi-ts/src/plugins/@hey-api/sdk/config.ts

···
 import { definePluginConfig } from '~/plugins/shared/utils/config';
 
 import { handler } from './plugin';
+import { resolveStructure } from './structure';
 import type { HeyApiSdkPlugin } from './types';
 
 export const defaultConfig: HeyApiSdkPlugin['Config'] = {
   config: {
-    asClass: false,
     auth: true,
-    classNameBuilder: '{{name}}',
-    classStructure: 'auto',
     client: true,
     exportFromIndex: true,
-    instance: '',
-    methodNameBuilder: '{{name}}',
-    operationId: true,
     paramsStructure: 'grouped',
-    response: 'body',
     responseStyle: 'fields',
     transformer: false,
     validator: false,
+
+    // Deprecated - kept for backward compatibility
+    // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+    asClass: false,
+    classNameBuilder: '{{name}}',
+    classStructure: 'auto',
+    instance: '',
+    methodNameBuilder: '{{name}}',
+    operationId: true,
+    response: 'body',
   },
   dependencies: ['@hey-api/typescript'],
   handler,
···
       plugin.config.validator.response = false;
     }
 
-    if (plugin.config.instance) {
-      if (typeof plugin.config.instance !== 'string') {
-        plugin.config.instance = 'Sdk';
-      }
-
-      plugin.config.asClass = true;
-    } else {
-      plugin.config.instance = '';
-    }
-
-    // Set default classNameBuilder based on client type
-    if (plugin.config.classNameBuilder === '{{name}}') {
-      if (plugin.config.client === '@hey-api/client-angular') {
-        plugin.config.classNameBuilder = '{{name}}Service';
-      }
-    }
+    plugin.config.structure = resolveStructure(plugin.config, context);
   },
 };
 

packages/openapi-ts/src/plugins/@hey-api/sdk/model/resource.ts

···
-import type { Symbol } from '@hey-api/codegen-core';
-
-import type { IR } from '~/ir/types';
-import { getClientPlugin } from '~/plugins/@hey-api/client-core/utils';
-import {
-  createOperationComment,
-  isOperationOptionsRequired,
-} from '~/plugins/shared/utils/operation';
-import { $ } from '~/ts-dsl';
-import { toCase } from '~/utils/to-case';
-
-import { createClientClass, createRegistryClass } from '../shared/class';
-import { nuxtTypeComposable, nuxtTypeDefault } from '../shared/constants';
-import {
-  operationClassName,
-  operationMethodName,
-  operationParameters,
-  operationStatements,
-} from '../shared/operation';
-import type { HeyApiSdkPlugin } from '../types';
-
-export type Event = {
-  operation: IR.OperationObject;
-  path: ReadonlyArray<string | number>;
-  tags: ReadonlyArray<string> | undefined;
-};
-
-/**
- * Represents a resource layer in the SDK hierarchy.
- *
- * Resources can be nested (via children) and contain operations (methods).
- */
-export class SdkResourceModel {
-  /** Nested resources within this resource. */
-  children: Map<string, SdkResourceModel> = new Map();
-  /** The name of this resource (e.g., "Users", "Accounts"). */
-  name: string;
-  /** Operations that will become methods in this resource. */
-  operations: Array<Event> = [];
-  /** Parent resource in the hierarchy. Undefined if this is the root resource. */
-  parent?: SdkResourceModel;
-
-  constructor(name: string, parent?: SdkResourceModel) {
-    this.name = name;
-    this.parent = parent;
-  }
-
-  get isRoot(): boolean {
-    return !this.parent;
-  }
-
-  /**
-   * Gets or creates a child resource.
-   *
-   * If the child doesn't exist, it's created automatically.
-   *
-   * @param name - The name of the child resource
-   * @returns The child resource instance
-   */
-  child(name: string): SdkResourceModel {
-    if (!this.children.has(name)) {
-      this.children.set(name, new SdkResourceModel(name, this));
-    }
-    return this.children.get(name)!;
-  }
-
-  /**
-   * Gets the full path of this resource in the hierarchy.
-   *
-   * @returns An array of resource names from the root to this resource
-   */
-  getPath(): ReadonlyArray<string> {
-    const path: Array<string> = [];
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let cursor: SdkResourceModel | undefined = this;
-    while (cursor) {
-      path.unshift(cursor.name);
-      cursor = cursor.parent;
-    }
-    return path;
-  }
-
-  /**
-   * Inserts an operation event into the resource tree.
-   *
-   * Parses the operation ID and creates the resource hierarchy.
-   */
-  insert(event: Event, plugin: HeyApiSdkPlugin['Instance']): void {
-    const { operation } = event;
-    const classSegments =
-      this.name &&
-      plugin.config.classStructure === 'auto' &&
-      operation.operationId
-        ? this.splitOperationId(operation.operationId).slice(0, -1)
-        : [];
-
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let cursor: SdkResourceModel = this;
-    for (const segment of classSegments) {
-      cursor = cursor.child(segment);
-    }
-
-    cursor.operations.push(event);
-  }
-
-  /**
-   * Converts this class group to a class node.
-   */
-  toNode(plugin: HeyApiSdkPlugin['Instance']): {
-    dependencies: Array<ReturnType<typeof $.class>>;
-    nodes: ReadonlyArray<ReturnType<typeof $.class | typeof $.var>>;
-  } {
-    const dependencies: Array<ReturnType<typeof $.class>> = [];
-    const nodes: Array<ReturnType<typeof $.class | typeof $.var>> = [];
-
-    const client = getClientPlugin(plugin.context.config);
-    const isAngularClient = client.name === '@hey-api/client-angular';
-
-    if (this.name) {
-      const { node, symbol: symbolClass } = this.classToNode(plugin);
-
-      if (this.isRoot && plugin.config.instance) {
-        this.enrichRootClass({
-          dependencies,
-          node,
-          plugin,
-          symbol: symbolClass,
-        });
-      }
-
-      this.operations.forEach((event, index) => {
-        const { operation } = event;
-        if (index > 0 || node.hasBody) node.newline();
-        node.do(
-          this.implementFn({
-            node: $.method(this.createFnSymbol(plugin, event), (m) =>
-              this.attachComment({
-                node: m,
-                operation,
-              })
-                .public()
-                .static(!isAngularClient && !plugin.config.instance),
-            ),
-            operation,
-            plugin,
-          }),
-        );
-      });
-
-      for (const child of this.children.values()) {
-        if (node.hasBody) node.newline();
-        node.do(...this.childToNode(child, plugin));
-      }
-
-      nodes.push(node);
-    } else {
-      this.operations.forEach((event) => {
-        const { operation } = event;
-        let node = $.const(this.createFnSymbol(plugin, event))
-          .export()
-          .assign(
-            this.implementFn({
-              node: $.func(),
-              operation,
-              plugin,
-            }),
-          );
-        node = this.attachComment({ node, operation });
-        nodes.push(node);
-      });
-    }
-
-    return { dependencies, nodes };
-  }
-
-  /**
-   * Recursively walks the tree depth-first.
-   *
-   * Yields this node, then all descendants.
-   */
-  *walk(): Generator<SdkResourceModel> {
-    for (const child of this.children.values()) {
-      yield* child.walk();
-    }
-    yield this;
-  }
-
-  private attachComment<
-    T extends ReturnType<typeof $.var | typeof $.method>,
-  >(args: { node: T; operation: IR.OperationObject }): T {
-    const { node, operation } = args;
-    return node.$if(createOperationComment(operation), (m, v) => m.doc(v)) as T;
-  }
-
-  private createFnSymbol(
-    plugin: HeyApiSdkPlugin['Instance'],
-    event: Event,
-  ): Symbol {
-    const { operation, path, tags } = event;
-    const extractFromOperationId =
-      this.name && plugin.config.classStructure === 'auto';
-    return plugin.symbol(
-      operationMethodName({
-        operation,
-        plugin,
-        value:
-          extractFromOperationId && operation.operationId
-            ? toCase(
-                this.splitOperationId(operation.operationId).pop()!,
-                'camelCase',
-              )
-            : operation.id,
-      }),
-      {
-        meta: {
-          category: 'sdk',
-          path,
-          resource: 'operation',
-          resourceId: operation.id,
-          tags,
-          tool: 'sdk',
-        },
-      },
-    );
-  }
-
-  private childToNode(
-    resource: SdkResourceModel,
-    plugin: HeyApiSdkPlugin['Instance'],
-  ): ReadonlyArray<ReturnType<typeof $.field | typeof $.getter>> {
-    const refChild = plugin.referenceSymbol({
-      category: 'utility',
-      resource: 'class',
-      resourceId: resource.getPath().join('.'),
-      tool: 'sdk',
-    });
-    const memberNameStr = toCase(refChild.name, 'camelCase');
-    const memberName = plugin.symbol(memberNameStr);
-    if (plugin.config.instance) {
-      const privateName = plugin.symbol(`_${memberNameStr}`);
-      return [
-        $.field(privateName, (f) => f.private().optional().type(refChild)),
-        $.getter(memberName, (g) =>
-          g.returns(refChild).do(
-            $('this')
-              .attr(privateName)
-              .nullishAssign(
-                $.new(refChild).args(
-                  $.object().prop('client', $('this').attr('client')),
-                ),
-              )
-              .return(),
-          ),
-        ),
-      ];
-    }
-    if (plugin.isSymbolRegistered(refChild.id)) {
-      return [$.field(memberName, (f) => f.static().assign($(refChild)))];
-    }
-    return [
-      $.getter(memberName, (g) => g.public().static().do($.return(refChild))),
-    ];
-  }
-
-  private classToNode(plugin: HeyApiSdkPlugin['Instance']): {
-    node: ReturnType<typeof $.class>;
-    symbol: Symbol;
-  } {
-    const client = getClientPlugin(plugin.context.config);
-    const isAngularClient = client.name === '@hey-api/client-angular';
-    const symbol = plugin.symbol(
-      operationClassName({ plugin, value: this.name }),
-      {
-        meta: {
-          category: 'utility',
-          resource: 'class',
-          resourceId: this.getPath().join('.'),
-          tool: 'sdk',
-        },
-      },
-    );
-    const node = $.class(symbol)
-      .export()
-      .$if(plugin.config.instance, (c) =>
-        c.extends(
-          plugin.referenceSymbol({
-            category: 'utility',
-            resource: 'class',
-            resourceId: 'HeyApiClient',
-            tool: 'sdk',
-          }),
-        ),
-      )
-      .$if(isAngularClient && this.isRoot, (c) =>
-        c.decorator(
-          plugin.referenceSymbol({
-            category: 'external',
-            resource: '@angular/core.Injectable',
-          }),
-          $.object().prop('providedIn', $.literal('root')),
-        ),
-      );
-    return { node, symbol };
-  }
-
-  private enrichRootClass(args: {
-    dependencies: Array<ReturnType<typeof $.class>>;
-    node: ReturnType<typeof $.class>;
-    plugin: HeyApiSdkPlugin['Instance'];
-    symbol: Symbol;
-  }): void {
-    const { dependencies, node, plugin, symbol } = args;
-    const symbolClient = plugin.symbol('HeyApiClient', {
-      meta: {
-        category: 'utility',
-        resource: 'class',
-        resourceId: 'HeyApiClient',
-        tool: 'sdk',
-      },
-    });
-    dependencies.push(createClientClass({ plugin, symbol: symbolClient }));
-    const symbolRegistry = plugin.symbol('HeyApiRegistry', {
-      meta: {
-        category: 'utility',
-        resource: 'class',
-        resourceId: 'HeyApiRegistry',
-        tool: 'sdk',
-      },
-    });
-    dependencies.push(
-      createRegistryClass({
-        plugin,
-        sdkSymbol: symbol,
-        symbol: symbolRegistry,
-      }),
-    );
-    const isClientRequired =
-      !plugin.config.client || !plugin.getSymbol({ category: 'client' });
-    const registry = plugin.symbol('__registry');
-    node.toAccessNode = (node, options) => {
-      if (options.context) return;
-      return $(node.name).attr(registry).attr('get').call();
-    };
-    node.do(
-      $.field(registry, (f) =>
-        f
-          .public()
-          .static()
-          .readonly()
-          .assign($.new(symbolRegistry).generic(symbol)),
-      ),
-      $.newline(),
-      $.init((i) =>
-        i
-          .param('args', (p) =>
-            p.required(isClientRequired).type(
-              $.type
-                .object()
-                .prop('client', (p) =>
-                  p.required(isClientRequired).type(
-                    plugin.referenceSymbol({
-                      category: 'external',
-                      resource: 'client.Client',
-                    }),
-                  ),
-                )
-                .prop('key', (p) => p.optional().type('string')),
-            ),
-          )
-          .do(
-            $('super').call('args'),
-            $(symbol)
-              .attr(registry)
-              .attr('set')
-              .call('this', $('args').attr('key').required(isClientRequired)),
-          ),
-      ),
-    );
-  }
-
-  private implementFn<
-    T extends ReturnType<typeof $.func | typeof $.method>,
-  >(args: {
-    node: T;
-    operation: IR.OperationObject;
-    plugin: HeyApiSdkPlugin['Instance'];
-  }): T {
-    const { node, operation, plugin } = args;
-    const client = getClientPlugin(plugin.context.config);
-    const isNuxtClient = client.name === '@hey-api/client-nuxt';
-    const isRequiredOptions = isOperationOptionsRequired({
-      context: plugin.context,
-      operation,
-    });
-    const opParameters = operationParameters({
-      isRequiredOptions,
-      operation,
-      plugin,
-    });
-    const statements = operationStatements({
-      isRequiredOptions,
-      opParameters,
-      operation,
-      plugin,
-    });
-    return node
-      .$if(
-        isNuxtClient,
-        (m) =>
-          m
-            .generic(nuxtTypeComposable, (t) =>
-              t
-                .extends(
-                  plugin.referenceSymbol({
-                    category: 'external',
-                    resource: 'client.Composable',
-                  }),
-                )
-                .default($.type.literal('$fetch')),
-            )
-            .generic(nuxtTypeDefault, (t) =>
-              t.$if(
-                plugin.querySymbol({
-                  category: 'type',
-                  resource: 'operation',
-                  resourceId: operation.id,
-                  role: 'response',
-                }),
-                (t, s) => t.extends(s).default(s),
-                (t) => t.default('undefined'),
-              ),
-            ),
-        (m) =>
-          m.generic('ThrowOnError', (t) =>
-            t
-              .extends('boolean')
-              .default(
-                ('throwOnError' in client.config
-                  ? client.config.throwOnError
-                  : false) ?? false,
-              ),
-          ),
-      )
-      .params(...opParameters.parameters)
-      .do(...statements) as T;
-  }
-
-  private splitOperationId(operationId: string): Array<string> {
-    // TODO: expose this logic
-    return operationId.split(/[./]/).filter(Boolean);
-  }
-}

packages/openapi-ts/src/plugins/@hey-api/sdk/model/structure.ts

···
-import type { HeyApiSdkPlugin } from '../types';
-import type { Event } from './resource';
-import { SdkResourceModel } from './resource';
-
-export class SdkStructureModel {
-  /** If true, generates a flat SDK without resource hierarchy. */
-  private _flat: boolean;
-  /** Name of the SDK. If empty, we fallback to operation tags. */
-  private _name: string;
-  /** Root resources mapped by their names. */
-  private _roots: Map<string, SdkResourceModel> = new Map();
-
-  constructor(
-    name: string,
-    options?: {
-      /** If true, generates a flat SDK without resource hierarchy. */
-      flat?: boolean;
-    },
-  ) {
-    this._flat = options?.flat ?? false;
-    this._name = name;
-  }
-
-  /**
-   * Inserts an operation event into the structure.
-   *
-   * Parses the operation ID and organizes it into classes based on tags.
-   */
-  insert(event: Event, plugin: HeyApiSdkPlugin['Instance']): void {
-    const { operation } = event;
-    const roots = this._name
-      ? [this._name]
-      : this._flat
-        ? ['']
-        : operation.tags && operation.tags.length > 0
-          ? operation.tags
-          : ['default'];
-
-    for (const name of roots) {
-      const resource = this.root(name);
-      resource.insert(event, plugin);
-    }
-  }
-
-  /**
-   * Gets or creates a root resource by name.
-   *
-   * If the root doesn't exist, it's created automatically.
-   *
-   * @param name - The name of the root resource
-   * @returns The root resource instance
-   */
-  root(name: string): SdkResourceModel {
-    if (!this._roots.has(name)) {
-      this._roots.set(name, new SdkResourceModel(name));
-    }
-    return this._roots.get(name)!;
-  }
-
-  /**
-   * Recursively walks the structure.
-   *
-   * Yields all resources in the structure.
-   */
-  *walk(): Generator<SdkResourceModel> {
-    for (const resource of this._roots.values()) {
-      yield* resource.walk();
-    }
-  }
-}

packages/openapi-ts/src/plugins/@hey-api/sdk/shared/operation.ts

···
 import { sanitizeNamespaceIdentifier } from '~/openApi/common/parser/sanitize';
 import { getClientPlugin } from '~/plugins/@hey-api/client-core/utils';
 import { $ } from '~/ts-dsl';
-import { toCase } from '~/utils/to-case';
+import { toCase } from '~/utils/naming';
 
 import type { Field, Fields } from '../../client-core/bundle/params';
 import type { HeyApiSdkPlugin } from '../types';
···
   path: ReadonlyArray<string>;
 }
 
+/**
+ * @deprecated
+ */
 export const operationClassName = ({
   plugin,
   value,
···
   );
 };
 
+/**
+ * @deprecated
+ */
 export const operationMethodName = ({
   operation,
   plugin,
···
   return (
     (typeof plugin.config.methodNameBuilder === 'string'
       ? plugin.config.methodNameBuilder.replace('{{name}}', name)
-      : plugin.config.methodNameBuilder?.(name, operation)) || name
+      : // @ts-expect-error TODO: remove
+        plugin.config.methodNameBuilder?.(name, operation)) || name
   );
 };
 

packages/openapi-ts/src/plugins/@hey-api/sdk/shared/signature.ts

···
 import type { IR } from '~/ir/types';
 import type { PluginInstance } from '~/plugins/shared/utils/instance';
+import { toCase } from '~/utils/naming';
 import { refToName } from '~/utils/ref';
-import { toCase } from '~/utils/to-case';
 
 import type { Field } from '../../client-core/bundle/params';
 

packages/openapi-ts/src/plugins/@hey-api/sdk/shared/typeOptions.ts

···
   const client = getClientPlugin(plugin.context.config);
   const isNuxtClient = client.name === '@hey-api/client-nuxt';
 
-  const symbolTDataShape = plugin.registerSymbol({
+  const symbolTDataShape = plugin.symbol('TDataShape', {
     external: clientModule,
     kind: 'type',
-    name: 'TDataShape',
   });
-  const symbolClient = plugin.registerSymbol({
+  const symbolClient = plugin.symbol('Client', {
     external: clientModule,
     kind: 'type',
     meta: {
···
       resource: 'client.Client',
       tool: client.name,
     },
-    name: 'Client',
   });
-  const symbolClientOptions = plugin.registerSymbol({
+  const symbolClientOptions = plugin.symbol('Options', {
     external: clientModule,
     kind: 'type',
-    name: 'Options',
   });
-  const symbolOptions = plugin.registerSymbol({
+  const symbolOptions = plugin.symbol('Options', {
     meta: {
       category: 'type',
       resource: 'client-options',
       tool: 'sdk',
     },
-    name: 'Options',
   });
 
   const typeOptions = $.type

packages/openapi-ts/src/plugins/@hey-api/sdk/structure/config.ts

···
+import type { PluginContext } from '~/plugins/types';
+import type { NamingConfig, NamingRule } from '~/utils/naming';
+import { resolveNaming } from '~/utils/naming';
+
+import type { UserConfig } from '../types';
+import type {
+  StructureConfig,
+  StructureStrategy,
+  UserStructureConfig,
+} from './types';
+
+type Config = Omit<UserConfig, 'name'>;
+
+// container: 'class',
+// containerName: {},
+// defaultTag: 'default',
+// delimiters: /[./]/,
+// methodName: {},
+// methods: 'instance',
+// nesting: 'operationId',
+// segmentName: {},
+// strategy: 'flat',
+
+export function resolveStructure(
+  config: Config,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _context: PluginContext,
+): StructureConfig {
+  // if (plugin.config.instance) {
+  //   if (typeof plugin.config.instance !== 'string') {
+  //     plugin.config.instance = 'Sdk';
+  //   }
+
+  //   plugin.config.asClass = true;
+  // } else {
+  //   plugin.config.instance = '';
+  // }
+
+  // // Set default classNameBuilder based on client type
+  // if (plugin.config.classNameBuilder === '{{name}}') {
+  //   if (plugin.config.client === '@hey-api/client-angular') {
+  //     plugin.config.classNameBuilder = '{{name}}Service';
+  //   }
+  // }
+
+  // Check for deprecated options and warn
+  if (config.asClass !== undefined) {
+    console.warn(
+      '`asClass` is deprecated. Use `grouping: "byTags"` or `grouping: "single"` instead.',
+    );
+  }
+
+  if (config.instance !== undefined) {
+    console.warn(
+      '`instance` is deprecated. Use `grouping: { strategy: "single", containerName: "Name", methods: "instance" }` instead.',
+    );
+  }
+
+  if (config.classStructure !== undefined) {
+    console.warn(
+      '`classStructure` is deprecated. Use `grouping: { nesting: "operationId" }` or `grouping: { nesting: "id" }` instead.',
+    );
+  }
+
+  if (config.classNameBuilder !== undefined) {
+    console.warn(
+      '`classNameBuilder` is deprecated. Use `grouping.containerName` instead.',
+    );
+  }
+
+  if (config.methodNameBuilder !== undefined) {
+    console.warn(
+      '`methodNameBuilder` is deprecated. Use `grouping.methodName` instead.',
+    );
+  }
+
+  if (config.operationId !== undefined) {
+    console.warn(
+      '`operationId` is deprecated. Use `grouping: { nesting: "operationId" }` or `grouping: { nesting: "id" }` instead.',
+    );
+  }
+
+  // If new grouping config is provided, use it
+  if (config.structure !== undefined) {
+    return normalizeStructureConfig(config.structure);
+  }
+
+  // Otherwise, map legacy config to new grouping config
+  return mapLegacyToGrouping(config);
+}
+
+function normalizeStructureConfig(
+  input: StructureStrategy | UserStructureConfig,
+): StructureConfig {
+  // String shorthand
+  if (typeof input === 'string') {
+    return {
+      container: 'class',
+      containerName: input === 'single' ? { name: 'Sdk' } : {},
+      defaultTag: 'default',
+      delimiters: /[./]/,
+      methodName: {},
+      methods: 'instance',
+      nesting: 'operationId',
+      segmentName: {},
+      strategy: input,
+    };
+  }
+
+  // Custom function
+  if (typeof input === 'function') {
+    return {
+      container: 'class',
+      containerName: {},
+      defaultTag: 'default',
+      delimiters: /[./]/,
+      methodName: {},
+      methods: 'instance',
+      nesting: 'operationId',
+      segmentName: {},
+      strategy: input,
+    };
+  }
+
+  // Full config object
+  const strategy = input.strategy ?? 'flat';
+
+  return {
+    container: input.container ?? 'class',
+    containerName: resolveContainerName(input.containerName, strategy),
+    defaultTag: input.defaultTag ?? 'default',
+    delimiters: input.delimiters ?? /[./]/,
+    methodName: resolveNaming(input.methodName),
+    methods: input.methods ?? 'instance',
+    nesting: input.nesting ?? 'operationId',
+    segmentName: resolveNaming(input.segmentName),
+    strategy,
+  };
+}
+
+function resolveContainerName(
+  input: NamingRule | undefined,
+  strategy: StructureStrategy,
+): NamingConfig {
+  const resolved = resolveNaming(input);
+
+  // Default name for 'single' strategy
+  if (strategy === 'single' && !resolved.name) {
+    resolved.name = 'Sdk';
+  }
+
+  return resolved;
+}
+
+function mapLegacyToGrouping(config: Config): StructureConfig {
+  // Determine strategy from legacy options
+  let strategy: StructureStrategy = 'flat';
+
+  if (config.asClass) {
+    strategy = config.instance ? 'single' : 'byTags';
+  }
+
+  // Determine container name
+  let containerName: NamingConfig = {};
+
+  if (config.instance && typeof config.instance === 'string') {
+    containerName = { name: config.instance };
+  } else if (config.classNameBuilder) {
+    containerName = resolveNaming(config.classNameBuilder);
+  }
+
+  if (strategy === 'single' && !containerName.name) {
+    containerName.name = 'Sdk';
+  }
+
+  // Determine method name
+  const methodName: NamingConfig = config.methodNameBuilder
+    ? resolveNaming(config.methodNameBuilder)
+    : {};
+
+  // Determine nesting
+  let nesting: 'operationId' | 'id' = 'operationId';
+
+  if (config.classStructure === 'off' || config.operationId === false) {
+    nesting = 'id';
+  }
+
+  // Determine methods style
+  const methods = config.instance ? 'instance' : 'static';
+
+  return {
+    container: 'class',
+    containerName,
+    defaultTag: 'default',
+    delimiters: /[./]/,
+    methodName,
+    methods,
+    nesting,
+    segmentName: {},
+    strategy,
+  };
+}

packages/openapi-ts/src/plugins/@hey-api/sdk/structure/index.ts

···
+export { resolveStructure } from './config';
+export type {
+  StructureConfig,
+  StructureStrategy,
+  UserStructureConfig,
+} from './types';

packages/openapi-ts/src/plugins/@hey-api/sdk/structure/types.d.ts

···
+import type { IR } from '~/ir/types';
+import type { OperationPathStrategy } from '~/openApi/shared/locations';
+import type { NamingConfig, NamingRule } from '~/utils/naming';
+
+type CustomStructureStrategy = (
+  operation: IR.OperationObject,
+) => ReadonlyArray<ReadonlyArray<string>>;
+
+export type StructureStrategy =
+  | 'byTags'
+  | 'flat'
+  | 'single'
+  | CustomStructureStrategy;
+
+export interface UserStructureConfig {
+  /**
+   * Type of container for grouped operations.
+   *
+   * Ignored when `strategy` is `'flat'`.
+   *
+   * - `'class'` - Class with methods
+   * - `'object'` - Plain object literal
+   *
+   * @default 'class'
+   */
+  container?: 'class' | 'object';
+  /**
+   * Customize container names (class or object variable names).
+   *
+   * For `'single'` strategy, this sets the root container name.
+   * For `'byTags'` strategy, this transforms tag names.
+   *
+   * @default 'Sdk' for `'single'` strategy
+   *
+   * @example
+   * // Set root name for single strategy
+   * containerName: 'MyApi'
+   *
+   * @example
+   * // Transform tag names with suffix
+   * containerName: '{{name}}Service'
+   *
+   * @example
+   * // With casing
+   * containerName: { name: '{{name}}Service', case: 'PascalCase' }
+   */
+  containerName?: NamingRule;
+  /**
+   * Default container name for operations without tags.
+   *
+   * Only applies when `strategy` is `'byTags'`.
+   *
+   * @default 'default'
+   */
+  defaultTag?: string;
+  /**
+   * Delimiters for splitting operationId.
+   *
+   * Only applies when `nesting` is `'operationId'`.
+   *
+   * @default /[./]/
+   */
+  delimiters?: RegExp;
+  /**
+   * Customize method/function names.
+   *
+   * Applied to the final segment of the path (the method name).
+   */
+  methodName?: NamingRule;
+  /**
+   * How methods are attached to class containers.
+   *
+   * Only applies when `container` is `'class'`.
+   *
+   * - `'static'` - Static methods, no instantiation required
+   * - `'instance'` - Instance methods, requires `new ClassName(config)`
+   *
+   * @default 'instance'
+   */
+  methods?: 'instance' | 'static';
+  /**
+   * How to derive nesting structure from operations.
+   *
+   * Ignored when `strategy` is `'flat'`.
+   *
+   * - `'operationId'` - Split operationId by delimiters (e.g., `users.list` → `Users.list()`)
+   * - `'id'` - Use operation id as-is, no nesting
+   * - Custom function for full control
+   *
+   * @default 'operationId'
+   */
+  nesting?: 'operationId' | 'id' | OperationPathStrategy;
+  /**
+   * Customize nesting segment names.
+   *
+   * Applied to intermediate path segments (not the method name).
+   */
+  segmentName?: NamingRule;
+  /**
+   * Grouping strategy.
+   *
+   * - `'flat'` - Standalone functions, no grouping
+   * - `'byTags'` - One container per operation tag
+   * - `'single'` - All operations in one container
+   * - Custom function for full control
+   *
+   * @default 'flat'
+   */
+  strategy?: StructureStrategy;
+}
+
+export interface StructureConfig {
+  /**
+   * Type of container for grouped operations.
+   *
+   * Ignored when `strategy` is `'flat'`.
+   *
+   * - `'class'` - Class with methods
+   * - `'object'` - Plain object literal
+   */
+  container: 'class' | 'object';
+  /**
+   * Customize container names (class or object variable names).
+   *
+   * For `'single'` strategy, this sets the root container name.
+   * For `'byTags'` strategy, this transforms tag names.
+   *
+   * @default 'Sdk' for `'single'` strategy
+   *
+   * @example
+   * // Set root name for single strategy
+   * containerName: 'MyApi'
+   *
+   * @example
+   * // Transform tag names with suffix
+   * containerName: '{{name}}Service'
+   *
+   * @example
+   * // With casing
+   * containerName: { name: '{{name}}Service', case: 'PascalCase' }
+   */
+  containerName: NamingConfig;
+  /**
+   * Default container name for operations without tags.
+   *
+   * Only applies when `strategy` is `'byTags'`.
+   */
+  defaultTag: string;
+  /**
+   * Delimiters for splitting operationId.
+   *
+   * Only applies when `nesting` is `'operationId'`.
+   */
+  delimiters: RegExp;
+  /**
+   * Customize method/function names.
+   *
+   * Applied to the final segment of the path (the method name).
+   */
+  methodName: NamingConfig;
+  /**
+   * How methods are attached to class containers.
+   *
+   * Only applies when `container` is `'class'`.
+   *
+   * - `'static'` - Static methods, no instantiation required
+   * - `'instance'` - Instance methods, requires `new ClassName(config)`
+   */
+  methods: 'instance' | 'static';
+  /**
+   * How to derive nesting structure from operations.
+   *
+   * Ignored when `strategy` is `'flat'`.
+   *
+   * - `'operationId'` - Split operationId by delimiters (e.g., `users.list` → `Users.list()`)
+   * - `'id'` - Use operation id as-is, no nesting
+   * - Custom function for full control
+   */
+  nesting: 'operationId' | 'id' | OperationPathStrategy;
+  /**
+   * Customize nesting segment names.
+   *
+   * Applied to intermediate path segments (not the method name).
+   */
+  segmentName: NamingConfig;
+  /**
+   * Grouping strategy.
+   *
+   * - `'flat'` - Standalone functions, no grouping
+   * - `'byTags'` - One container per operation tag
+   * - `'single'` - All operations in one container
+   * - Custom function for full control
+   */
+  strategy: StructureStrategy;
+}

packages/openapi-ts/src/plugins/@hey-api/sdk/types.d.ts

···
-import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
 import type { PluginClientNames, PluginValidatorNames } from '~/plugins/types';
-import type { StringName } from '~/types/case';
+import type { NameTransformer } from '~/utils/naming';
+
+import type {
+  StructureConfig,
+  StructureStrategy,
+  UserStructureConfig,
+} from './structure';
 
 export type UserConfig = Plugin.Name<'@hey-api/sdk'> &
   Plugin.Hooks & {
     /**
-     * Group operation methods into classes? When enabled, you can select which
-     * classes to export with `sdk.include` and/or transform their names with
-     * `sdk.classNameBuilder`.
-     *
-     * Note that by enabling this option, your SDKs will **NOT**
-     * support {@link https://developer.mozilla.org/docs/Glossary/Tree_shaking tree-shaking}.
-     * For this reason, it is disabled by default.
-     *
-     * @default false
-     */
-    asClass?: boolean;
-    /**
      * Should the generated functions contain auth mechanisms? You may want to
      * disable this option if you're handling auth yourself or defining it
      * globally on the client and want to reduce the size of generated code.
···
      */
     auth?: boolean;
     /**
-     * Customize the generated class names. The name variable is obtained from
-     * your OpenAPI specification tags or `instance` value.
-     *
-     * This option has no effect if `sdk.asClass` is `false`.
-     */
-    classNameBuilder?: StringName;
-    /**
-     * How should we structure your SDK? By default, we try to infer the ideal
-     * structure using `operationId` keywords. If you prefer a flatter structure,
-     * you can set `classStructure` to `off` to disable this behavior.
-     *
-     * @default 'auto'
-     */
-    classStructure?: 'auto' | 'off';
-    /**
      * Use an internal client instance to send HTTP requests? This is useful if
      * you don't want to manually pass the client to each SDK function.
      *
···
      */
     exportFromIndex?: boolean;
     /**
-     * Include only service classes with names matching regular expression
-     *
-     * This option has no effect if `sdk.asClass` is `false`.
-     */
-    include?: string;
-    /**
-     * Set `instance` to create an instantiable SDK. Using `true` will use the
-     * default instance name; in practice, you want to define your own by passing
-     * a string value.
-     *
-     * @default false
-     */
-    instance?: string | boolean;
-    /**
-     * Customise the name of methods within the service. By default,
-     * `operation.id` is used.
-     */
-    methodNameBuilder?:
-      | string
-      | ((name: string, operation: IR.OperationObject) => string);
-    // TODO: parser - rename operationId option to something like inferId?: boolean
-    /**
-     * Use operation ID to generate operation names?
-     *
-     * @default true
-     */
-    operationId?: boolean;
-    /**
      * Define how request parameters are structured in generated SDK methods.
      *
      * - `'flat'` merges parameters into a single object.
···
      */
     responseStyle?: 'data' | 'fields';
     /**
+     * Define how generated outputs are structurally organized.
+     */
+    structure?: {
+      /**
+       * Define the structure of generated SDK operations.
+       *
+       * String shorthand:
+       * - `'flat'` – standalone functions, no container
+       * - `'byTags'` – one container per operation tag
+       * - `'single'` – all operations in a single container
+       * - custom function for full control
+       *
+       * Use the object form for advanced configuration.
+       *
+       * @default 'flat'
+       */
+      operations?: StructureStrategy | UserStructureConfig;
+    };
+    /**
      * Transform response data before returning. This is useful if you want to
      * convert for example ISO strings into Date objects. However, transformation
      * adds runtime overhead, so it's not recommended to use unless necessary.
···
     // DEPRECATED OPTIONS BELOW
 
     /**
-     * **This feature works only with the legacy parser**
-     *
-     * Filter endpoints to be included in the generated SDK. The provided
-     * string should be a regular expression where matched results will be
-     * included in the output. The input pattern this string will be tested
-     * against is `{method} {path}`. For example, you can match
-     * `POST /api/v1/foo` with `^POST /api/v1/foo$`.
-     *
-     * @deprecated
-     */
-    // eslint-disable-next-line typescript-sort-keys/interface
-    filter?: string;
-    /**
-     * Define shape of returned value from service calls
-     *
-     * @deprecated
-     * @default 'body'
-     */
-    response?: 'body' | 'response';
-  };
-
-export type Config = Plugin.Name<'@hey-api/sdk'> &
-  Plugin.Hooks & {
-    /**
      * Group operation methods into classes? When enabled, you can select which
      * classes to export with `sdk.include` and/or transform their names with
      * `sdk.classNameBuilder`.
···
      * support {@link https://developer.mozilla.org/docs/Glossary/Tree_shaking tree-shaking}.
      * For this reason, it is disabled by default.
      *
+     * @deprecated Use `grouping: 'byTags'` or `grouping: 'single'` instead.
      * @default false
      */
-    asClass: boolean;
-    /**
-     * Should the generated functions contain auth mechanisms? You may want to
-     * disable this option if you're handling auth yourself or defining it
-     * globally on the client and want to reduce the size of generated code.
-     *
-     * @default true
-     */
-    auth: boolean;
+    // eslint-disable-next-line typescript-sort-keys/interface
+    asClass?: boolean;
     /**
      * Customize the generated class names. The name variable is obtained from
      * your OpenAPI specification tags or `instance` value.
      *
      * This option has no effect if `sdk.asClass` is `false`.
+     *
+     * @deprecated Use `grouping.containerName` instead.
      */
-    classNameBuilder: StringName;
+    classNameBuilder?: NameTransformer;
     /**
      * How should we structure your SDK? By default, we try to infer the ideal
      * structure using `operationId` keywords. If you prefer a flatter structure,
      * you can set `classStructure` to `off` to disable this behavior.
      *
+     * @deprecated Use `grouping: { nesting: 'operationId' }` or `grouping: { nesting: 'id' }` instead.
      * @default 'auto'
      */
-    classStructure: 'auto' | 'off';
+    classStructure?: 'auto' | 'off';
     /**
-     * Use an internal client instance to send HTTP requests? This is useful if
-     * you don't want to manually pass the client to each SDK function.
+     * Set `instance` to create an instantiable SDK. Using `true` will use the
+     * default instance name; in practice, you want to define your own by passing
+     * a string value.
      *
-     * You can customize the selected client output through its plugin. You can
-     * also set `client` to `true` to automatically choose the client from your
-     * defined plugins. If we can't detect a client plugin when using `true`, we
-     * will default to `@hey-api/client-fetch`.
+     * @deprecated Use `grouping: { strategy: 'single', as: 'Name', methods: 'instance' }` instead.
+     * @default false
+     */
+    instance?: string | boolean;
+    /**
+     * Customise the name of methods within the service. By default,
+     * `operation.id` is used.
      *
-     * @default true
+     * @deprecated Use `grouping.methodName` instead.
      */
-    client: PluginClientNames | false;
+    methodNameBuilder?: NameTransformer;
     /**
-     * Should the exports from the generated files be re-exported in the index
-     * barrel file?
+     * Use operation ID to generate operation names?
      *
+     * @deprecated Use `grouping.nesting: 'operationId'` or `grouping.nesting: 'id'` instead.
      * @default true
      */
-    exportFromIndex: boolean;
+    operationId?: boolean;
     /**
-     * Include only service classes with names matching regular expression
+     * Define shape of returned value from service calls
      *
-     * This option has no effect if `sdk.asClass` is `false`.
+     * @deprecated
+     * @default 'body'
      */
-    include: string | undefined;
+    response?: 'body' | 'response';
+  };
+
+export type Config = Plugin.Name<'@hey-api/sdk'> &
+  Plugin.Hooks & {
     /**
-     * Set `instance` to create an instantiable SDK. Using `true` will use the
-     * default instance name; in practice, you want to define your own by passing
-     * a string value.
+     * Should the generated functions contain auth mechanisms? You may want to
+     * disable this option if you're handling auth yourself or defining it
+     * globally on the client and want to reduce the size of generated code.
+     *
+     * @default true
      */
-    instance: string;
+    auth: boolean;
     /**
-     * Customise the name of methods within the service. By default,
-     * `operation.id` is used.
+     * Use an internal client instance to send HTTP requests? This is useful if
+     * you don't want to manually pass the client to each SDK function.
+     *
+     * You can customize the selected client output through its plugin. You can
+     * also set `client` to `true` to automatically choose the client from your
+     * defined plugins. If we can't detect a client plugin when using `true`, we
+     * will default to `@hey-api/client-fetch`.
+     *
+     * @default true
      */
-    methodNameBuilder:
-      | string
-      | ((name: string, operation: IR.OperationObject) => string);
-    // TODO: parser - rename operationId option to something like inferId?: boolean
+    client: PluginClientNames | false;
     /**
-     * Use operation ID to generate operation names?
+     * Should the exports from the generated files be re-exported in the index
+     * barrel file?
      *
      * @default true
      */
-    operationId: boolean;
+    exportFromIndex: boolean;
     /**
      * Define how request parameters are structured in generated SDK methods.
      *
···
      */
     responseStyle: 'data' | 'fields';
     /**
+     * Define how generated outputs are structurally organized.
+     */
+    structure: {
+      /**
+       * Define the structure of generated SDK operations.
+       */
+      operations: StructureConfig;
+    };
+    /**
      * Transform response data before returning. This is useful if you want to
      * convert for example ISO strings into Date objects. However, transformation
      * adds runtime overhead, so it's not recommended to use unless necessary.
···
     // DEPRECATED OPTIONS BELOW
 
     /**
-     * **This feature works only with the legacy parser**
+     * Group operation methods into classes? When enabled, you can select which
+     * classes to export with `sdk.include` and/or transform their names with
+     * `sdk.classNameBuilder`.
      *
-     * Filter endpoints to be included in the generated SDK. The provided
-     * string should be a regular expression where matched results will be
-     * included in the output. The input pattern this string will be tested
-     * against is `{method} {path}`. For example, you can match
-     * `POST /api/v1/foo` with `^POST /api/v1/foo$`.
+     * Note that by enabling this option, your SDKs will **NOT**
+     * support {@link https://developer.mozilla.org/docs/Glossary/Tree_shaking tree-shaking}.
+     * For this reason, it is disabled by default.
      *
-     * @deprecated
+     * @deprecated Use `grouping: 'byTags'` or `grouping: 'single'` instead.
+     * @default false
      */
     // eslint-disable-next-line typescript-sort-keys/interface
-    filter?: string;
+    asClass: boolean;
+    /**
+     * Customize the generated class names. The name variable is obtained from
+     * your OpenAPI specification tags or `instance` value.
+     *
+     * This option has no effect if `sdk.asClass` is `false`.
+     *
+     * @deprecated Use `grouping.containerName` instead.
+     */
+    classNameBuilder: NameTransformer;
+    /**
+     * How should we structure your SDK? By default, we try to infer the ideal
+     * structure using `operationId` keywords. If you prefer a flatter structure,
+     * you can set `classStructure` to `off` to disable this behavior.
+     *
+     * @deprecated Use `grouping: { nesting: 'operationId' }` or `grouping: { nesting: 'id' }` instead.
+     * @default 'auto'
+     */
+    classStructure: 'auto' | 'off';
+    /**
+     * Set `instance` to create an instantiable SDK. Using `true` will use the
+     * default instance name; in practice, you want to define your own by passing
+     * a string value.
+     *
+     * @deprecated Use `grouping: { strategy: 'single', as: 'Name', methods: 'instance' }` instead.
+     */
+    instance: string;
+    /**
+     * Customise the name of methods within the service. By default,
+     * `operation.id` is used.
+     *
+     * @deprecated Use `grouping.methodName` instead.
+     */
+    methodNameBuilder: NameTransformer;
+    /**
+     * Use operation ID to generate operation names?
+     *
+     * @deprecated Use `grouping.nesting: 'operationId'` or `grouping.nesting: 'id'` instead.
+     * @default true
+     */
+    operationId: boolean;
     /**
      * Define shape of returned value from service calls
      *

packages/openapi-ts/src/plugins/@hey-api/sdk/v1/plugin.ts

···
+import type {
+  StructureItem,
+  StructureNode,
+  StructureShell,
+  Symbol,
+} from '@hey-api/codegen-core';
+import { StructureModel } from '@hey-api/codegen-core';
+
 import { clientFolderAbsolutePath } from '~/generate/client';
+import type { IR } from '~/ir/types';
+import {
+  OperationLocations,
+  type OperationLocationStrategy,
+  OperationPath,
+} from '~/openApi/shared/locations';
 import { getClientPlugin } from '~/plugins/@hey-api/client-core/utils';
-import type { $ } from '~/ts-dsl';
+import {
+  createOperationComment,
+  isOperationOptionsRequired,
+} from '~/plugins/shared/utils/operation';
+import { $ } from '~/ts-dsl';
+import { toCase } from '~/utils/naming';
 
-import { SdkStructureModel } from '../model/structure';
+import { createClientClass, createRegistryClass } from '../shared/class';
+import { nuxtTypeComposable, nuxtTypeDefault } from '../shared/constants';
+import {
+  operationClassName,
+  operationMethodName,
+  operationParameters,
+  operationStatements,
+} from '../shared/operation';
 import { createTypeOptions } from '../shared/typeOptions';
 import type { HeyApiSdkPlugin } from '../types';
 
+interface OperationItem {
+  operation: IR.OperationObject;
+  path: ReadonlyArray<string | number>;
+  tags: ReadonlyArray<string> | undefined;
+}
+
+const source = globalThis.Symbol('@hey-api/sdk');
+
+function attachComment<
+  T extends ReturnType<typeof $.var | typeof $.method>,
+>(args: { node: T; operation: IR.OperationObject }): T {
+  const { node, operation } = args;
+  return node.$if(createOperationComment(operation), (m, v) => m.doc(v)) as T;
+}
+
+function createFnSymbol(
+  plugin: HeyApiSdkPlugin['Instance'],
+  item: StructureItem & { data: OperationItem },
+): Symbol {
+  const { operation, path, tags } = item.data;
+  const name = item.location[item.location.length - 1];
+  return plugin.symbol(
+    operationMethodName({
+      operation,
+      plugin,
+      value: name,
+    }),
+    {
+      meta: {
+        category: 'sdk',
+        path,
+        resource: 'operation',
+        resourceId: operation.id,
+        tags,
+        tool: 'sdk',
+      },
+    },
+  );
+}
+
+function childToNode(
+  resource: StructureNode,
+  plugin: HeyApiSdkPlugin['Instance'],
+): ReadonlyArray<ReturnType<typeof $.field | typeof $.getter>> {
+  const refChild = plugin.referenceSymbol({
+    category: 'utility',
+    resource: 'class',
+    resourceId: resource.getPath().join('.'),
+    tool: 'sdk',
+  });
+  const memberNameStr = toCase(refChild.name, 'camelCase');
+  const memberName = plugin.symbol(memberNameStr);
+  if (plugin.config.instance) {
+    const privateName = plugin.symbol(`_${memberNameStr}`);
+    return [
+      $.field(privateName, (f) => f.private().optional().type(refChild)),
+      $.getter(memberName, (g) =>
+        g.returns(refChild).do(
+          $('this')
+            .attr(privateName)
+            .nullishAssign(
+              $.new(refChild).args(
+                $.object().prop('client', $('this').attr('client')),
+              ),
+            )
+            .return(),
+        ),
+      ),
+    ];
+  }
+  if (plugin.isSymbolRegistered(refChild.id)) {
+    return [$.field(memberName, (f) => f.static().assign($(refChild)))];
+  }
+  return [
+    $.getter(memberName, (g) => g.public().static().do($.return(refChild))),
+  ];
+}
+
+function enrichRootClass(args: {
+  dependencies: Array<ReturnType<typeof $.class>>;
+  node: ReturnType<typeof $.class>;
+  plugin: HeyApiSdkPlugin['Instance'];
+  symbol: Symbol;
+}): void {
+  const { dependencies, node, plugin, symbol } = args;
+  const symbolClient = plugin.symbol('HeyApiClient', {
+    meta: {
+      category: 'utility',
+      resource: 'class',
+      resourceId: 'HeyApiClient',
+      tool: 'sdk',
+    },
+  });
+  dependencies.push(createClientClass({ plugin, symbol: symbolClient }));
+  const symbolRegistry = plugin.symbol('HeyApiRegistry', {
+    meta: {
+      category: 'utility',
+      resource: 'class',
+      resourceId: 'HeyApiRegistry',
+      tool: 'sdk',
+    },
+  });
+  dependencies.push(
+    createRegistryClass({
+      plugin,
+      sdkSymbol: symbol,
+      symbol: symbolRegistry,
+    }),
+  );
+  const isClientRequired =
+    !plugin.config.client || !plugin.getSymbol({ category: 'client' });
+  const registry = plugin.symbol('__registry');
+  node.toAccessNode = (node, options) => {
+    if (options.context) return;
+    return $(node.name).attr(registry).attr('get').call();
+  };
+  node.do(
+    $.field(registry, (f) =>
+      f
+        .public()
+        .static()
+        .readonly()
+        .assign($.new(symbolRegistry).generic(symbol)),
+    ),
+    $.newline(),
+    $.init((i) =>
+      i
+        .param('args', (p) =>
+          p.required(isClientRequired).type(
+            $.type
+              .object()
+              .prop('client', (p) =>
+                p.required(isClientRequired).type(
+                  plugin.referenceSymbol({
+                    category: 'external',
+                    resource: 'client.Client',
+                  }),
+                ),
+              )
+              .prop('key', (p) => p.optional().type('string')),
+          ),
+        )
+        .do(
+          $('super').call('args'),
+          $(symbol)
+            .attr(registry)
+            .attr('set')
+            .call('this', $('args').attr('key').required(isClientRequired)),
+        ),
+    ),
+  );
+}
+
+function implementFn<
+  T extends ReturnType<typeof $.func | typeof $.method>,
+>(args: {
+  node: T;
+  operation: IR.OperationObject;
+  plugin: HeyApiSdkPlugin['Instance'];
+}): T {
+  const { node, operation, plugin } = args;
+  const client = getClientPlugin(plugin.context.config);
+  const isNuxtClient = client.name === '@hey-api/client-nuxt';
+  const isRequiredOptions = isOperationOptionsRequired({
+    context: plugin.context,
+    operation,
+  });
+  const opParameters = operationParameters({
+    isRequiredOptions,
+    operation,
+    plugin,
+  });
+  const statements = operationStatements({
+    isRequiredOptions,
+    opParameters,
+    operation,
+    plugin,
+  });
+  return node
+    .$if(
+      isNuxtClient,
+      (m) =>
+        m
+          .generic(nuxtTypeComposable, (t) =>
+            t
+              .extends(
+                plugin.referenceSymbol({
+                  category: 'external',
+                  resource: 'client.Composable',
+                }),
+              )
+              .default($.type.literal('$fetch')),
+          )
+          .generic(nuxtTypeDefault, (t) =>
+            t.$if(
+              plugin.querySymbol({
+                category: 'type',
+                resource: 'operation',
+                resourceId: operation.id,
+                role: 'response',
+              }),
+              (t, s) => t.extends(s).default(s),
+              (t) => t.default('undefined'),
+            ),
+          ),
+      (m) =>
+        m.generic('ThrowOnError', (t) =>
+          t
+            .extends('boolean')
+            .default(
+              ('throwOnError' in client.config
+                ? client.config.throwOnError
+                : false) ?? false,
+            ),
+        ),
+    )
+    .params(...opParameters.parameters)
+    .do(...statements) as T;
+}
+
+/**
+ * Converts this class group to a class node.
+ */
+function toNode(
+  model: StructureNode,
+  plugin: HeyApiSdkPlugin['Instance'],
+): {
+  dependencies?: Array<ReturnType<typeof $.class>>;
+  nodes: ReadonlyArray<ReturnType<typeof $.class | typeof $.var>>;
+} {
+  if (model.virtual) {
+    const nodes: Array<ReturnType<typeof $.var>> = [];
+    for (const item of model.itemsFrom<OperationItem>(source)) {
+      const { operation } = item.data;
+      let node = $.const(createFnSymbol(plugin, item))
+        .export()
+        .assign(
+          implementFn({
+            node: $.func(),
+            operation,
+            plugin,
+          }),
+        );
+      node = attachComment({ node, operation });
+      nodes.push(node);
+    }
+    return { nodes };
+  }
+
+  if (!model.shell) {
+    return { nodes: [] };
+  }
+
+  const nodes: Array<ReturnType<typeof $.class>> = [];
+
+  const client = getClientPlugin(plugin.context.config);
+  const isAngularClient = client.name === '@hey-api/client-angular';
+
+  const shell = model.shell.define(model);
+  const node = shell.node as ReturnType<typeof $.class>;
+
+  let index = 0;
+  for (const item of model.itemsFrom<OperationItem>(source)) {
+    const { operation } = item.data;
+    if (index > 0 || node.hasBody) node.newline();
+    node.do(
+      implementFn({
+        node: $.method(createFnSymbol(plugin, item), (m) =>
+          attachComment({
+            node: m,
+            operation,
+          })
+            .public()
+            .static(!isAngularClient && !plugin.config.instance),
+        ),
+        operation,
+        plugin,
+      }),
+    );
+    index += 1;
+  }
+
+  for (const child of model.children.values()) {
+    if (node.hasBody) node.newline();
+    node.do(...childToNode(child, plugin));
+  }
+
+  nodes.push(node);
+
+  return {
+    dependencies: shell.dependencies as Array<ReturnType<typeof $.class>>,
+    nodes,
+  };
+}
+
+function createShell(plugin: HeyApiSdkPlugin['Instance']): StructureShell {
+  const client = getClientPlugin(plugin.context.config);
+  const isAngularClient = client.name === '@hey-api/client-angular';
+  return {
+    define: (node) => {
+      const symbol = plugin.symbol(
+        operationClassName({ plugin, value: node.name }),
+        {
+          meta: {
+            category: 'utility',
+            resource: 'class',
+            resourceId: node.getPath().join('.'),
+            tool: 'sdk',
+          },
+        },
+      );
+      const c = $.class(symbol)
+        .export()
+        .$if(plugin.config.instance, (c) =>
+          c.extends(
+            plugin.referenceSymbol({
+              category: 'utility',
+              resource: 'class',
+              resourceId: 'HeyApiClient',
+              tool: 'sdk',
+            }),
+          ),
+        )
+        .$if(isAngularClient && node.isRoot, (c) =>
+          c.decorator(
+            plugin.referenceSymbol({
+              category: 'external',
+              resource: '@angular/core.Injectable',
+            }),
+            $.object().prop('providedIn', $.literal('root')),
+          ),
+        );
+
+      const dependencies: Array<ReturnType<typeof $.class>> = [];
+
+      if (node.isRoot && plugin.config.instance) {
+        enrichRootClass({
+          dependencies,
+          node: c,
+          plugin,
+          symbol,
+        });
+      }
+
+      return { dependencies, node: c };
+    },
+  };
+}
+
+function resolveLocationStrategy(
+  plugin: HeyApiSdkPlugin['Instance'],
+): OperationLocationStrategy {
+  const shell = createShell(plugin);
+  const path =
+    plugin.config.classStructure === 'auto'
+      ? OperationPath.fromOperationId()
+      : OperationPath.id();
+
+  if (!plugin.config.asClass) {
+    return OperationLocations.flat();
+  }
+
+  if (plugin.config.instance) {
+    return OperationLocations.single({
+      path,
+      root: plugin.config.instance,
+      shell,
+    });
+  }
+
+  return OperationLocations.byTags({
+    fallback: 'default',
+    path,
+    shell,
+  });
+}
+
 export const handlerV1: HeyApiSdkPlugin['Handler'] = ({ plugin }) => {
   const clientModule = clientFolderAbsolutePath(plugin.context.config);
   const client = getClientPlugin(plugin.context.config);
···
 
   createTypeOptions({ plugin });
 
-  const structure = plugin.config.asClass
-    ? new SdkStructureModel(plugin.config.instance)
-    : new SdkStructureModel('', { flat: true });
+  const structure = new StructureModel();
+  const locationStrategy = resolveLocationStrategy(plugin);
 
   plugin.forEach(
     'operation',
     (event) => {
-      structure.insert(
-        {
+      structure.insert({
+        data: {
           operation: event.operation,
           path: event._path,
           tags: event.tags,
-        },
-        plugin,
-      );
+        } satisfies OperationItem,
+        // TODO: expose this logic
+        locations: locationStrategy(event.operation),
+        source,
+      });
     },
     { order: 'declarations' },
   );
···
   const allDependencies: Array<ReturnType<typeof $.class>> = [];
   const allNodes: Array<ReturnType<typeof $.class | typeof $.var>> = [];
 
-  for (const model of structure.walk()) {
-    const { dependencies, nodes } = model.toNode(plugin);
-    allDependencies.push(...dependencies);
+  for (const node of structure.walk()) {
+    const { dependencies, nodes } = toNode(node, plugin);
+    allDependencies.push(...(dependencies ?? []));
     allNodes.push(...nodes);
   }
 

packages/openapi-ts/src/plugins/@hey-api/transformers/plugin.ts

···
 
 import { createOperationKey, operationResponsesMap } from '~/ir/operation';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 import { refToName } from '~/utils/ref';
 
 import type { HeyApiTransformersPlugin } from './types';
···
     const symbol =
       plugin.getSymbol(query) ??
       plugin.symbol(
-        buildName({
-          config: {
-            case: 'camelCase',
-            name: '{{name}}SchemaResponseTransformer',
-          },
-          name: refToName(schema.$ref),
+        applyNaming(refToName(schema.$ref), {
+          case: 'camelCase',
+          name: '{{name}}SchemaResponseTransformer',
         }),
         {
           meta: query,
···
         schema: response,
       });
       if (!nodes.length) return;
-      const symbol = plugin.registerSymbol({
-        meta: {
-          category: 'transform',
-          resource: 'operation',
-          resourceId: operation.id,
-          role: 'response',
+      const symbol = plugin.symbol(
+        applyNaming(operation.id, {
+          case: 'camelCase',
+          name: '{{name}}ResponseTransformer',
+        }),
+        {
+          meta: {
+            category: 'transform',
+            resource: 'operation',
+            resourceId: operation.id,
+            role: 'response',
+          },
         },
-        name: buildName({
-          config: {
-            case: 'camelCase',
-            name: '{{name}}ResponseTransformer',
-          },
-          name: operation.id,
-        }),
-      });
+      );
       const value = $.const(symbol)
         .export()
         .assign(

packages/openapi-ts/src/plugins/@hey-api/typescript/shared/clientOptions.ts

···
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import {
   getClientBaseUrlKey,
   getClientPlugin,
 } from '~/plugins/@hey-api/client-core/utils';
 import type { TypeTsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 import { parseUrl } from '~/utils/url';
 
 import type { HeyApiTypeScriptPlugin } from '../types';
···
   }
 
   const symbol = plugin.symbol(
-    buildName({
-      config: {
-        case: plugin.config.case,
-      },
-      name: 'ClientOptions',
+    applyNaming('ClientOptions', {
+      case: plugin.config.case,
     }),
     {
       meta: {

packages/openapi-ts/src/plugins/@hey-api/typescript/shared/export.ts

···
 import { fromRef } from '@hey-api/codegen-core';
 
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { createSchemaComment } from '~/plugins/shared/utils/schema';
 import type { MaybeTsDsl, TypeTsDsl } from '~/ts-dsl';
 import { $, regexp } from '~/ts-dsl';
+import { applyNaming, toCase } from '~/utils/naming';
 import { pathToJsonPointer, refToName } from '~/utils/ref';
-import { toCase } from '~/utils/to-case';
 
 import type { HeyApiTypeScriptPlugin } from '../types';
 import type { IrSchemaToAstOptions } from './types';
···
         );
       }
 
-      const symbolObject = plugin.registerSymbol({
-        meta: {
-          category: 'utility',
-          path: fromRef(state.path),
-          resource: 'definition',
-          resourceId: $ref,
-          tags: fromRef(state.tags),
-          tool: 'typescript',
+      const symbolObject = plugin.symbol(
+        applyNaming(refToName($ref), plugin.config.definitions),
+        {
+          meta: {
+            category: 'utility',
+            path: fromRef(state.path),
+            resource: 'definition',
+            resourceId: $ref,
+            tags: fromRef(state.tags),
+            tool: 'typescript',
+          },
         },
-        name: buildName({
-          config: plugin.config.definitions,
-          name: refToName($ref),
-        }),
-      });
+      );
       const objectNode = $.const(symbolObject)
         .export()
         .$if(createSchemaComment(schema), (c, v) => c.doc(v))
···
         );
       plugin.node(objectNode);
 
-      const symbol = plugin.registerSymbol({
-        meta: {
-          category: 'type',
-          path: fromRef(state.path),
-          resource: 'definition',
-          resourceId: $ref,
-          tags: fromRef(state.tags),
-          tool: 'typescript',
+      const symbol = plugin.symbol(
+        applyNaming(refToName($ref), plugin.config.definitions),
+        {
+          meta: {
+            category: 'type',
+            path: fromRef(state.path),
+            resource: 'definition',
+            resourceId: $ref,
+            tags: fromRef(state.tags),
+            tool: 'typescript',
+          },
         },
-        name: buildName({
-          config: plugin.config.definitions,
-          name: refToName($ref),
-        }),
-      });
+      );
       const node = $.type
         .alias(symbol)
         .export()
···
         (type) => type !== 'number' && type !== 'string',
       );
       if (shouldCreateTypeScriptEnum) {
-        const symbol = plugin.registerSymbol({
-          meta: {
-            category: 'type',
-            path: fromRef(state.path),
-            resource: 'definition',
-            resourceId: $ref,
-            tags: fromRef(state.tags),
-            tool: 'typescript',
+        const symbol = plugin.symbol(
+          applyNaming(refToName($ref), plugin.config.definitions),
+          {
+            meta: {
+              category: 'type',
+              path: fromRef(state.path),
+              resource: 'definition',
+              resourceId: $ref,
+              tags: fromRef(state.tags),
+              tool: 'typescript',
+            },
           },
-          name: buildName({
-            config: plugin.config.definitions,
-            name: refToName($ref),
-          }),
-        });
+        );
         const enumNode = $.enum(symbol)
           .export()
           .$if(createSchemaComment(schema), (e, v) => e.doc(v))
···
     }
   }
 
-  const symbol = plugin.registerSymbol({
-    meta: {
-      category: 'type',
-      path: fromRef(state.path),
-      resource: 'definition',
-      resourceId: $ref,
-      tags: fromRef(state.tags),
-      tool: 'typescript',
+  const symbol = plugin.symbol(
+    applyNaming(refToName($ref), plugin.config.definitions),
+    {
+      meta: {
+        category: 'type',
+        path: fromRef(state.path),
+        resource: 'definition',
+        resourceId: $ref,
+        tags: fromRef(state.tags),
+        tool: 'typescript',
+      },
     },
-    name: buildName({
-      config: plugin.config.definitions,
-      name: refToName($ref),
-    }),
-  });
+  );
   const node = $.type
     .alias(symbol)
     .export()

packages/openapi-ts/src/plugins/@hey-api/typescript/shared/operation.ts

···
 import { operationResponsesMap } from '~/ir/operation';
 import { deduplicateSchema } from '~/ir/schema';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { irSchemaToAst } from '../v1/plugin';
 import type { IrSchemaToAstOptions } from './types';
···
 
   data.required = dataRequired;
 
-  const symbol = plugin.registerSymbol({
-    meta: {
-      category: 'type',
-      path: fromRef(state.path),
-      resource: 'operation',
-      resourceId: operation.id,
-      role: 'data',
-      tags: fromRef(state.tags),
-      tool: 'typescript',
+  const symbol = plugin.symbol(
+    applyNaming(operation.id, plugin.config.requests),
+    {
+      meta: {
+        category: 'type',
+        path: fromRef(state.path),
+        resource: 'operation',
+        resourceId: operation.id,
+        role: 'data',
+        tags: fromRef(state.tags),
+        tool: 'typescript',
+      },
     },
-    name: buildName({
-      config: plugin.config.requests,
-      name: operation.id,
-    }),
-  });
+  );
   const node = $.type
     .alias(symbol)
     .export()
···
     operationResponsesMap(operation);
 
   if (errors) {
-    const symbolErrors = plugin.registerSymbol({
-      meta: {
-        category: 'type',
-        path: fromRef(state.path),
-        resource: 'operation',
-        resourceId: operation.id,
-        role: 'errors',
-        tags: fromRef(state.tags),
-        tool: 'typescript',
+    const symbolErrors = plugin.symbol(
+      applyNaming(operation.id, plugin.config.errors),
+      {
+        meta: {
+          category: 'type',
+          path: fromRef(state.path),
+          resource: 'operation',
+          resourceId: operation.id,
+          role: 'errors',
+          tags: fromRef(state.tags),
+          tool: 'typescript',
+        },
       },
-      name: buildName({
-        config: plugin.config.errors,
-        name: operation.id,
-      }),
-    });
+    );
     const node = $.type
       .alias(symbolErrors)
       .export()
···
     plugin.node(node);
 
     if (error) {
-      const symbol = plugin.registerSymbol({
-        meta: {
-          category: 'type',
-          path: fromRef(state.path),
-          resource: 'operation',
-          resourceId: operation.id,
-          role: 'error',
-          tags: fromRef(state.tags),
-          tool: 'typescript',
+      const symbol = plugin.symbol(
+        applyNaming(operation.id, {
+          case: plugin.config.errors.case,
+          name: plugin.config.errors.error,
+        }),
+        {
+          meta: {
+            category: 'type',
+            path: fromRef(state.path),
+            resource: 'operation',
+            resourceId: operation.id,
+            role: 'error',
+            tags: fromRef(state.tags),
+            tool: 'typescript',
+          },
         },
-        name: buildName({
-          config: {
-            case: plugin.config.errors.case,
-            name: plugin.config.errors.error,
-          },
-          name: operation.id,
-        }),
-      });
+      );
       const node = $.type
         .alias(symbol)
         .export()
···
   }
 
   if (responses) {
-    const symbolResponses = plugin.registerSymbol({
-      meta: {
-        category: 'type',
-        path: fromRef(state.path),
-        resource: 'operation',
-        resourceId: operation.id,
-        role: 'responses',
-        tags: fromRef(state.tags),
-        tool: 'typescript',
+    const symbolResponses = plugin.symbol(
+      applyNaming(operation.id, plugin.config.responses),
+      {
+        meta: {
+          category: 'type',
+          path: fromRef(state.path),
+          resource: 'operation',
+          resourceId: operation.id,
+          role: 'responses',
+          tags: fromRef(state.tags),
+          tool: 'typescript',
+        },
       },
-      name: buildName({
-        config: plugin.config.responses,
-        name: operation.id,
-      }),
-    });
+    );
     const node = $.type
       .alias(symbolResponses)
       .export()
···
     plugin.node(node);
 
     if (response) {
-      const symbol = plugin.registerSymbol({
-        meta: {
-          category: 'type',
-          path: fromRef(state.path),
-          resource: 'operation',
-          resourceId: operation.id,
-          role: 'response',
-          tags: fromRef(state.tags),
-          tool: 'typescript',
+      const symbol = plugin.symbol(
+        applyNaming(operation.id, {
+          case: plugin.config.responses.case,
+          name: plugin.config.responses.response,
+        }),
+        {
+          meta: {
+            category: 'type',
+            path: fromRef(state.path),
+            resource: 'operation',
+            resourceId: operation.id,
+            role: 'response',
+            tags: fromRef(state.tags),
+            tool: 'typescript',
+          },
         },
-        name: buildName({
-          config: {
-            case: plugin.config.responses.case,
-            name: plugin.config.responses.response,
-          },
-          name: operation.id,
-        }),
-      });
+      );
       const node = $.type
         .alias(symbol)
         .export()

packages/openapi-ts/src/plugins/@hey-api/typescript/shared/webhook.ts

···
 import { fromRef } from '@hey-api/codegen-core';
 
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { createSchemaComment } from '~/plugins/shared/utils/schema';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { irSchemaToAst } from '../v1/plugin';
 import type { IrSchemaToAstOptions } from './types';
···
   }
 
   if (operation.body) {
-    const symbolWebhookPayload = plugin.registerSymbol({
-      meta: {
-        category: 'type',
-        path: fromRef(state.path),
-        resource: 'webhook',
-        resourceId: operation.id,
-        role: 'data',
-        tags: fromRef(state.tags),
-        tool: 'typescript',
-      },
-      name: buildName({
-        config: {
-          case: plugin.config.webhooks.case,
-          name: plugin.config.webhooks.payload,
-        },
-        name: operation.id,
+    const symbolWebhookPayload = plugin.symbol(
+      applyNaming(operation.id, {
+        case: plugin.config.webhooks.case,
+        name: plugin.config.webhooks.payload,
       }),
-    });
+      {
+        meta: {
+          category: 'type',
+          path: fromRef(state.path),
+          resource: 'webhook',
+          resourceId: operation.id,
+          role: 'data',
+          tags: fromRef(state.tags),
+          tool: 'typescript',
+        },
+      },
+    );
     const node = $.type
       .alias(symbolWebhookPayload)
       .export()
···
 
   data.required = dataRequired;
 
-  const symbolWebhookRequest = plugin.registerSymbol({
-    meta: {
-      category: 'type',
-      path: fromRef(state.path),
-      resource: 'webhook',
-      resourceId: operation.id,
-      role: 'data',
-      tags: fromRef(state.tags),
-      tool: 'typescript',
+  const symbolWebhookRequest = plugin.symbol(
+    applyNaming(operation.id, plugin.config.webhooks),
+    {
+      meta: {
+        category: 'type',
+        path: fromRef(state.path),
+        resource: 'webhook',
+        resourceId: operation.id,
+        role: 'data',
+        tags: fromRef(state.tags),
+        tool: 'typescript',
+      },
     },
-    name: buildName({
-      config: plugin.config.webhooks,
-      name: operation.id,
-    }),
-  });
+  );
   const node = $.type
     .alias(symbolWebhookRequest)
     .export()

packages/openapi-ts/src/plugins/@hey-api/typescript/types.d.ts

···
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 import type { IApi } from './api';
 
···
      *
      * @default 'PascalCase'
      */
-    case?: Exclude<StringCase, 'SCREAMING_SNAKE_CASE'>;
+    case?: Exclude<Casing, 'SCREAMING_SNAKE_CASE'>;
     /**
      * Configuration for reusable schema definitions.
      *
···
      * @default '{{name}}'
      */
     definitions?:
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated definition names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Custom naming pattern for generated definition names. The name variable
            * is obtained from the schema name.
            *
            * @default '{{name}}'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * By default, enums are emitted as types to preserve runtime-free output.
···
            *
            * @default 'SCREAMING_SNAKE_CASE'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * When generating enums as JavaScript objects, they'll contain a null
            * value if they're nullable. This might be undesirable if you want to do
···
      * @default '{{name}}Errors'
      */
     errors?:
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated error type names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Custom naming pattern for generated error type names. The name
            * variable is obtained from the operation name.
            *
            * @default '{{name}}Error'
            */
-          error?: StringName;
+          error?: NameTransformer;
           /**
            * Custom naming pattern for generated error type names. The name
            * variable is obtained from the operation name.
            *
            * @default '{{name}}Errors'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Should the exports from the generated files be re-exported in the index
···
      * @default '{{name}}Data'
      */
     requests?:
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated request type names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Custom naming pattern for generated request type names. The name
            * variable is obtained from the operation name.
            *
            * @default '{{name}}Data'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for response-specific types.
···
      * @default '{{name}}Responses'
      */
     responses?:
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated response type names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Custom naming pattern for generated response type names. The name
            * variable is obtained from the operation name.
            *
            * @default '{{name}}Responses'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Custom naming pattern for generated response type names. The name
            * variable is obtained from the operation name.
            *
            * @default '{{name}}Response'
            */
-          response?: StringName;
+          response?: NameTransformer;
         };
     /**
      * The top type to use for untyped or unspecified schema values.
···
      * @default '{{name}}WebhookRequest'
      */
     webhooks?:
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated webhook type names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Custom naming pattern for generated webhook type names. The name
            * variable is obtained from the webhook key.
            *
            * @default '{{name}}WebhookRequest'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Custom naming pattern for generated webhook type names. The name
            * variable is obtained from the webhook key.
            *
            * @default '{{name}}WebhookPayload'
            */
-          payload?: StringName;
+          payload?: NameTransformer;
         };
   };
 
···
      *
      * @default 'PascalCase'
      */
-    case: Exclude<StringCase, 'SCREAMING_SNAKE_CASE'>;
+    case: Exclude<Casing, 'SCREAMING_SNAKE_CASE'>;
     /**
      * Configuration for reusable schema definitions.
      *
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Custom naming pattern for generated definition names. The name variable
        * is obtained from the schema name.
        *
        * @default '{{name}}'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * By default, enums are emitted as types to preserve runtime-free output.
···
        *
        * @default 'SCREAMING_SNAKE_CASE'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * When generating enums as JavaScript objects, they'll contain a null
        * value if they're nullable. This might be undesirable if you want to do
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Custom naming pattern for generated error type names. The name
        * variable is obtained from the operation name.
        *
        * @default '{{name}}Error'
        */
-      error: StringName;
+      error: NameTransformer;
       /**
        * Custom naming pattern for generated error type names. The name
        * variable is obtained from the operation name.
        *
        * @default '{{name}}Errors'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Should the exports from the generated files be re-exported in the index
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Custom naming pattern for generated request type names. The name
        * variable is obtained from the operation name.
        *
        * @default '{{name}}Data'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Configuration for response-specific types.
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Custom naming pattern for generated response type names. The name
        * variable is obtained from the operation name.
        *
        * @default '{{name}}Responses'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Custom naming pattern for generated response type names. The name
        * variable is obtained from the operation name.
        *
        * @default '{{name}}Response'
        */
-      response: StringName;
+      response: NameTransformer;
     };
     /**
      * The top type to use for untyped or unspecified schema values.
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Custom naming pattern for generated webhook type names. The name
        * variable is obtained from the webhook key.
        *
        * @default '{{name}}WebhookRequest'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Custom naming pattern for generated webhook type names. The name
        * variable is obtained from the webhook key.
        *
        * @default '{{name}}WebhookPayload'
        */
-      payload: StringName;
+      payload: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/@hey-api/typescript/v1/plugin.ts

···
 
 import { deduplicateSchema } from '~/ir/schema';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import type { SchemaWithType } from '~/plugins';
 import type { MaybeTsDsl, TypeTsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { createClientOptions } from '../shared/clientOptions';
 import { exportType } from '../shared/export';
···
 
   if (webhooks.length > 0) {
     const symbol = plugin.symbol(
-      buildName({
-        config: {
-          case: plugin.config.case,
-        },
-        name: 'Webhooks',
+      applyNaming('Webhooks', {
+        case: plugin.config.case,
       }),
       {
         meta: {

packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/string.ts

···
 import type { SchemaWithType } from '~/plugins';
 import type { TypeTsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
-import { toCase } from '~/utils/to-case';
+import { toCase } from '~/utils/naming';
 
 import type { IrSchemaToAstOptions } from '../../shared/types';
 
···
         };
 
         if (!plugin.getSymbol(queryTypeId)) {
-          const symbolTypeId = plugin.registerSymbol({
+          const symbolTypeId = plugin.symbol('TypeID', {
             meta: queryTypeId,
-            name: 'TypeID',
           });
           const nodeTypeId = $.type
             .alias(symbolTypeId)
···
         }
 
         const symbolTypeId = plugin.referenceSymbol(queryTypeId);
-        const symbolTypeName = plugin.registerSymbol({
-          meta: query,
-          name: toCase(`${type}_id`, plugin.config.case),
-        });
+        const symbolTypeName = plugin.symbol(
+          toCase(`${type}_id`, plugin.config.case),
+          {
+            meta: query,
+          },
+        );
         const node = $.type
           .alias(symbolTypeName)
           .export()

packages/openapi-ts/src/plugins/@pinia/colada/mutationOptions.ts

···
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { getClientPlugin } from '~/plugins/@hey-api/client-core/utils';
 import { createOperationComment } from '~/plugins/shared/utils/operation';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { handleMeta } from './meta';
 import type { PiniaColadaPlugin } from './types';
···
     .$if(handleMeta(plugin, operation, 'mutationOptions'), (o, v) =>
       o.prop('meta', v),
     );
-  const symbolMutationOptions = plugin.registerSymbol({
-    name: buildName({
-      config: plugin.config.mutationOptions,
-      name: operation.id,
-    }),
-  });
+  const symbolMutationOptions = plugin.symbol(
+    applyNaming(operation.id, plugin.config.mutationOptions),
+  );
   const statement = $.const(symbolMutationOptions)
     .export()
     .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>

packages/openapi-ts/src/plugins/@pinia/colada/queryKey.ts

···
 import { clientFolderAbsolutePath } from '~/generate/client';
 import { hasOperationDataRequired } from '~/ir/operation';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import {
   getClientBaseUrlKey,
   getClientPlugin,
 } from '~/plugins/@hey-api/client-core/utils';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import type { PiniaColadaPlugin } from './types';
 import { getPublicTypeData } from './utils';
···
 }: {
   plugin: PiniaColadaPlugin['Instance'];
 }) => {
-  const symbolCreateQueryKey = plugin.registerSymbol({
-    meta: {
-      category: 'utility',
-      resource: 'createQueryKey',
-      tool: plugin.name,
-    },
-    name: buildName({
-      config: {
-        case: plugin.config.case,
-      },
-      name: 'createQueryKey',
+  const symbolCreateQueryKey = plugin.symbol(
+    applyNaming('createQueryKey', {
+      case: plugin.config.case,
     }),
-  });
+    {
+      meta: {
+        category: 'utility',
+        resource: 'createQueryKey',
+        tool: plugin.name,
+      },
+    },
+  );
   const symbolQueryKeyType = plugin.referenceSymbol({
     category: 'type',
     resource: 'QueryKey',
···
   });
 
   const clientModule = clientFolderAbsolutePath(plugin.context.config);
-  const symbolSerializeQueryValue = plugin.registerSymbol({
+  const symbolSerializeQueryValue = plugin.symbol('serializeQueryKeyValue', {
     external: clientModule,
     meta: {
       category: 'external',
       resource: `${clientModule}.serializeQueryKeyValue`,
     },
-    name: 'serializeQueryKeyValue',
   });
 
   const fn = $.const(symbolCreateQueryKey).assign(
···
     resource: 'client-options',
     tool: 'sdk',
   });
-  const symbolQueryKeyType = plugin.registerSymbol({
+  const symbolQueryKeyType = plugin.symbol('QueryKey', {
     meta: {
       category: 'type',
       resource: 'QueryKey',
       tool: plugin.name,
     },
-    name: 'QueryKey',
   });
   const queryKeyType = $.type
     .alias(symbolQueryKeyType)

packages/openapi-ts/src/plugins/@pinia/colada/queryOptions.ts

···
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { getClientPlugin } from '~/plugins/@hey-api/client-core/utils';
 import {
   createOperationComment,
···
   isOperationOptionsRequired,
 } from '~/plugins/shared/utils/operation';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { handleMeta } from './meta';
 import {
···
 
   let keyExpression: ReturnType<typeof $.call>;
   if (plugin.config.queryKeys.enabled) {
-    const symbolQueryKey = plugin.registerSymbol({
-      name: buildName({
-        config: plugin.config.queryKeys,
-        name: operation.id,
-      }),
-    });
+    const symbolQueryKey = plugin.symbol(
+      applyNaming(operation.id, plugin.config.queryKeys),
+    );
     const node = queryKeyStatement({
       operation,
       plugin,
···
       o.prop('meta', v),
     );
 
-  const symbolQueryOptionsFn = plugin.registerSymbol({
-    meta: {
-      category: 'hook',
-      resource: 'operation',
-      resourceId: operation.id,
-      role: 'queryOptions',
-      tool: plugin.name,
+  const symbolQueryOptionsFn = plugin.symbol(
+    applyNaming(operation.id, plugin.config.queryOptions),
+    {
+      meta: {
+        category: 'hook',
+        resource: 'operation',
+        resourceId: operation.id,
+        role: 'queryOptions',
+        tool: plugin.name,
+      },
     },
-    name: buildName({
-      config: plugin.config.queryOptions,
-      name: operation.id,
-    }),
-  });
+  );
   const symbolDefineQueryOptions = plugin.referenceSymbol({
     category: 'external',
     resource: `${plugin.name}.defineQueryOptions`,

packages/openapi-ts/src/plugins/@pinia/colada/types.d.ts

···
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'@pinia/colada'> &
   Plugin.Hooks & {
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from SDK functions to the generated Pinia Colada code?
      *
···
      */
     mutationOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate mutation options helpers.
            *
···
            *
            * @default '{{name}}Mutation'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated query keys.
···
      */
     queryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query keys.
            *
···
            *
            * @default '{{name}}QueryKey'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     queryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query options helpers.
            *
···
            *
            * @default '{{name}}Query'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from SDK functions to the generated Pinia Colada code?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate mutation options helpers.
        *
···
        *
        * @default '{{name}}Mutation'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated query keys.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query keys.
        *
···
        *
        * @default '{{name}}QueryKey'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query options helpers.
        *
···
        *
        * @default '{{name}}Query'
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/@tanstack/angular-query-experimental/types.d.ts

···
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'@tanstack/angular-query-experimental'> &
   Plugin.Hooks & {
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
      */
     infiniteQueryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query key helpers.
            *
···
            * @default '{{name}}InfiniteQueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in infinite query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     infiniteQueryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query options helpers.
            *
···
            * @default '{{name}}InfiniteOptions'
            * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated mutation options helpers.
···
      */
     mutationOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate mutation options helpers.
            *
···
            * @default '{{name}}Mutation'
            * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated query keys.
···
      */
     queryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query keys.
            *
···
            * @default '{{name}}QueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     queryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query options helpers.
            *
···
            * @default '{{name}}Options'
            * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query key helpers.
        *
···
        * @default '{{name}}InfiniteQueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in infinite query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query options helpers.
        *
···
        * @default '{{name}}InfiniteOptions'
        * @see https://tanstack.com/query/v5/docs/framework/angular/reference/infiniteQueryOptions
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated mutation options helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate mutation options helpers.
        *
···
        * @default '{{name}}Mutation'
        * @see https://tanstack.com/query/v5/docs/framework/angular/reference/useMutation
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated query keys.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query keys.
        *
···
        * @default '{{name}}QueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryKey
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query options helpers.
        *
···
        * @default '{{name}}Options'
        * @see https://tanstack.com/query/v5/docs/framework/angular/reference/queryOptions
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/@tanstack/query-core/queryKey.ts

···
 
 import { hasOperationDataRequired } from '~/ir/operation';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { getClientBaseUrlKey } from '~/plugins/@hey-api/client-core/utils';
 import type { TsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { useTypeData } from './shared/useType';
 import type { PluginInstance } from './types';
···
 }: {
   plugin: PluginInstance;
 }) => {
-  const symbolCreateQueryKey = plugin.registerSymbol({
-    meta: {
-      category: 'utility',
-      resource: 'createQueryKey',
-      tool: plugin.name,
+  const symbolCreateQueryKey = plugin.symbol(
+    applyNaming('createQueryKey', {
+      case: plugin.config.case,
+    }),
+    {
+      meta: {
+        category: 'utility',
+        resource: 'createQueryKey',
+        tool: plugin.name,
+      },
     },
-    name: buildName({
-      config: {
-        case: plugin.config.case,
-      },
-      name: 'createQueryKey',
-    }),
-  });
+  );
   const symbolQueryKeyType = plugin.referenceSymbol({
     category: 'type',
     resource: 'QueryKey',
···
     resource: 'client-options',
     tool: 'sdk',
   });
-  const symbolQueryKeyType = plugin.registerSymbol({
+  const symbolQueryKeyType = plugin.symbol('QueryKey', {
     meta: {
       category: 'type',
       resource: 'QueryKey',
       tool: plugin.name,
     },
-    name: 'QueryKey',
   });
   const queryKeyType = $.type
     .alias(symbolQueryKeyType)

packages/openapi-ts/src/plugins/@tanstack/query-core/v5/infiniteQueryOptions.ts

···
 
 import { operationPagination } from '~/ir/operation';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import {
   createOperationComment,
   isOperationOptionsRequired,
 } from '~/plugins/shared/utils/operation';
 import type { TsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import {
   createQueryKeyFunction,
···
 }: {
   plugin: PluginInstance;
 }) => {
-  const symbolCreateInfiniteParams = plugin.registerSymbol({
-    meta: {
-      category: 'utility',
-      resource: 'createInfiniteParams',
-      tool: plugin.name,
+  const symbolCreateInfiniteParams = plugin.symbol(
+    applyNaming('createInfiniteParams', {
+      case: plugin.config.case,
+    }),
+    {
+      meta: {
+        category: 'utility',
+        resource: 'createInfiniteParams',
+        tool: plugin.name,
+      },
     },
-    name: buildName({
-      config: {
-        case: plugin.config.case,
-      },
-      name: 'createInfiniteParams',
-    }),
-  });
+  );
 
   const fn = $.const(symbolCreateInfiniteParams).assign(
     $.func()
···
     },
   });
 
-  const symbolInfiniteQueryKey = plugin.registerSymbol({
-    name: buildName({
-      config: plugin.config.infiniteQueryKeys,
-      name: operation.id,
-    }),
-  });
+  const symbolInfiniteQueryKey = plugin.symbol(
+    applyNaming(operation.id, plugin.config.infiniteQueryKeys),
+  );
   const node = queryKeyStatement({
     isInfinite: true,
     operation,
···
     );
   }
 
-  const symbolInfiniteQueryOptionsFn = plugin.registerSymbol({
-    name: buildName({
-      config: plugin.config.infiniteQueryOptions,
-      name: operation.id,
-    }),
-  });
+  const symbolInfiniteQueryOptionsFn = plugin.symbol(
+    applyNaming(operation.id, plugin.config.infiniteQueryOptions),
+  );
   const statement = $.const(symbolInfiniteQueryOptionsFn)
     .export()
     .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>

packages/openapi-ts/src/plugins/@tanstack/query-core/v5/mutationOptions.ts

···
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import { createOperationComment } from '~/plugins/shared/utils/operation';
 import type { TsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { handleMeta } from '../shared/meta';
 import { useTypeData, useTypeError, useTypeResponse } from '../shared/useType';
···
 
   const mutationOptionsFn = 'mutationOptions';
   const symbolMutationOptions = plugin.symbol(
-    buildName({
-      config: plugin.config.mutationOptions,
-      name: operation.id,
-    }),
+    applyNaming(operation.id, plugin.config.mutationOptions),
   );
   const statement = $.const(symbolMutationOptions)
     .export()

packages/openapi-ts/src/plugins/@tanstack/query-core/v5/queryOptions.ts

···
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import {
   createOperationComment,
   hasOperationSse,
···
 } from '~/plugins/shared/utils/operation';
 import type { TsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import {
   createQueryKeyFunction,
···
     resource: `${plugin.name}.queryOptions`,
   });
 
-  const symbolQueryKey = plugin.registerSymbol({
-    name: buildName({
-      config: plugin.config.queryKeys,
-      name: operation.id,
-    }),
-  });
+  const symbolQueryKey = plugin.symbol(
+    applyNaming(operation.id, plugin.config.queryKeys),
+  );
   const node = queryKeyStatement({
     isInfinite: false,
     operation,
···
       o.prop('meta', v),
     );
 
-  const symbolQueryOptionsFn = plugin.registerSymbol({
-    meta: {
-      category: 'hook',
-      resource: 'operation',
-      resourceId: operation.id,
-      role: 'queryOptions',
-      tool: plugin.name,
+  const symbolQueryOptionsFn = plugin.symbol(
+    applyNaming(operation.id, plugin.config.queryOptions),
+    {
+      meta: {
+        category: 'hook',
+        resource: 'operation',
+        resourceId: operation.id,
+        role: 'queryOptions',
+        tool: plugin.name,
+      },
     },
-    name: buildName({
-      config: plugin.config.queryOptions,
-      name: operation.id,
-    }),
-  });
+  );
   // TODO: add type error
   // TODO: AxiosError<PutSubmissionMetaError>
   const statement = $.const(symbolQueryOptionsFn)

packages/openapi-ts/src/plugins/@tanstack/query-core/v5/useQuery.ts

···
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import {
   createOperationComment,
   hasOperationSse,
   isOperationOptionsRequired,
 } from '~/plugins/shared/utils/operation';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import { useTypeData } from '../shared/useType';
 import type { PluginInstance } from '../types';
···
     return;
   }
 
-  const symbolUseQueryFn = plugin.registerSymbol({
-    name: buildName({
-      config: plugin.config.useQuery,
-      name: operation.id,
-    }),
-  });
+  const symbolUseQueryFn = plugin.symbol(
+    applyNaming(operation.id, plugin.config.useQuery),
+  );
 
   const symbolUseQuery = plugin.referenceSymbol({
     category: 'external',

packages/openapi-ts/src/plugins/@tanstack/react-query/types.d.ts

···
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'@tanstack/react-query'> &
   Plugin.Hooks & {
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
      */
     infiniteQueryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query key helpers.
            *
···
            *
            * @default '{{name}}InfiniteQueryKey'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in infinite query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     infiniteQueryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query options helpers.
            *
···
            *
            * @default '{{name}}InfiniteOptions'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated mutation options helpers.
···
      */
     mutationOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate mutation options helpers.
            *
···
            *
            * @default '{{name}}Mutation'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated query keys.
···
      */
     queryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query keys.
            *
···
            *
            * @default '{{name}}QueryKey'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     queryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query options helpers.
            *
···
            *
            * @default '{{name}}Options'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated `useQuery()` function helpers.
···
      */
     useQuery?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate `useQuery()` function helpers.
            *
···
            *
            * @default 'use{{name}}Query'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query key helpers.
        *
···
        *
        * @default '{{name}}InfiniteQueryKey'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in infinite query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query options helpers.
        *
···
        *
        * @default '{{name}}InfiniteOptions'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated mutation options helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate mutation options helpers.
        *
···
        *
        * @default '{{name}}Mutation'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated query keys.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query keys.
        *
···
        *
        * @default '{{name}}QueryKey'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query options helpers.
        *
···
        *
        * @default '{{name}}Options'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Configuration for generated `useQuery()` function helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate `useQuery()` function helpers.
        *
···
        *
        * @default 'use{{name}}Query'
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/@tanstack/solid-query/types.d.ts

···
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'@tanstack/solid-query'> &
   Plugin.Hooks & {
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
      */
     infiniteQueryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query key helpers.
            *
···
            * @default '{{name}}InfiniteQueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in infinite query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     infiniteQueryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query options helpers.
            *
···
            * @default '{{name}}InfiniteOptions'
            * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated mutation options helpers.
···
      */
     mutationOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate mutation options helpers.
            *
···
            * @default '{{name}}Mutation'
            * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated query keys.
···
      */
     queryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query keys.
            *
···
            * @default '{{name}}QueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     queryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query options helpers.
            *
···
            * @default '{{name}}Options'
            * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query key helpers.
        *
···
        * @default '{{name}}InfiniteQueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in infinite query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query options helpers.
        *
···
        * @default '{{name}}InfiniteOptions'
        * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createInfiniteQuery
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated mutation options helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate mutation options helpers.
        *
···
        * @default '{{name}}Mutation'
        * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createMutation
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated query keys.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query keys.
        *
···
        * @default '{{name}}QueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/solid/reference/queryKey
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query options helpers.
        *
···
        * @default '{{name}}Options'
        * @see https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/@tanstack/svelte-query/types.d.ts

···
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'@tanstack/svelte-query'> &
   Plugin.Hooks & {
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
      */
     infiniteQueryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query key helpers.
            *
···
            * @default '{{name}}InfiniteQueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in infinite query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     infiniteQueryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query options helpers.
            *
···
            * @default '{{name}}InfiniteOptions'
            * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated mutation options helpers.
···
      */
     mutationOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate mutation options helpers.
            *
···
            * @default '{{name}}Mutation'
            * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated query keys.
···
      */
     queryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query keys.
            *
···
            * @default '{{name}}QueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     queryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query options helpers.
            *
···
            * @default '{{name}}Options'
            * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query key helpers.
        *
···
        * @default '{{name}}InfiniteQueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in infinite query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query options helpers.
        *
···
        * @default '{{name}}InfiniteOptions'
        * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createinfinitequery
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated mutation options helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate mutation options helpers.
        *
···
        * @default '{{name}}Mutation'
        * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated query keys.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query keys.
        *
···
        * @default '{{name}}QueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/react/guides/query-keys
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query options helpers.
        *
···
        * @default '{{name}}Options'
        * @see https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/@tanstack/vue-query/types.d.ts

···
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'@tanstack/vue-query'> &
   Plugin.Hooks & {
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
      */
     infiniteQueryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query key helpers.
            *
···
            * @default '{{name}}InfiniteQueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in infinite query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     infiniteQueryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query options helpers.
            *
···
            * @default '{{name}}InfiniteOptions'
            * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated mutation options helpers.
···
      */
     mutationOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate mutation options helpers.
            *
···
            * @default '{{name}}Mutation'
            * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated query keys.
···
      */
     queryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query keys.
            *
···
            * @default '{{name}}QueryKey'
            * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     queryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query options helpers.
            *
···
            * @default '{{name}}Options'
            * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from SDK functions to the generated TanStack Query code?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query key helpers.
        *
···
        * @default '{{name}}InfiniteQueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in infinite query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query options helpers.
        *
···
        * @default '{{name}}InfiniteOptions'
        * @see https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated mutation options helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate mutation options helpers.
        *
···
        * @default '{{name}}Mutation'
        * @see https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated query keys.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query keys.
        *
···
        * @default '{{name}}QueryKey'
        * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryKey
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query options helpers.
        *
···
        * @default '{{name}}Options'
        * @see https://tanstack.com/query/v5/docs/framework/vue/reference/queryOptions
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/arktype/types.d.ts

···
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 import type { IApi } from './api';
 
···
      *
      * @default 'PascalCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from input to the generated Arktype schemas?
      *
···
      */
     definitions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Arktype schemas for reusable definitions.
            *
···
            *
            * @default '{{name}}'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Arktype schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Arktype schemas.
                    *
···
                    *
                    * @default '{{name}}'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
      */
     requests?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Arktype schemas for request definitions.
            *
···
            *
            * @default '{{name}}Data'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Arktype schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Arktype schemas.
                    *
···
                    *
                    * @default '{{name}}Data'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
      */
     responses?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Arktype schemas for response definitions.
            *
···
            *
            * @default '{{name}}Response'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Arktype schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Arktype schemas.
                    *
···
                    *
                    * @default '{{name}}Response'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
        */
       infer?:
         | boolean
-        | StringName
+        | NameTransformer
         | {
             /**
              * The casing convention to use for generated type names.
              *
              * @default 'PascalCase'
              */
-            case?: StringCase;
+            case?: Casing;
             /**
              * Whether to generate TypeScript types from Arktype schemas.
              *
···
      */
     webhooks?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Arktype schemas for webhook definitions.
            *
···
            *
            * @default '{{name}}WebhookRequest'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Arktype schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Arktype schemas.
                    *
···
                    *
                    * @default '{{name}}WebhookRequest'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
      *
      * @default 'PascalCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from input to the generated Arktype schemas?
      *
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Arktype schemas for reusable definitions.
        *
···
        *
        * @default '{{name}}'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Arktype schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Arktype schemas.
            *
···
            *
            * @default '{{name}}'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Arktype schemas for request definitions.
        *
···
        *
        * @default '{{name}}Data'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Arktype schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Arktype schemas.
            *
···
            *
            * @default '{{name}}Data'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Arktype schemas for response definitions.
        *
···
        *
        * @default '{{name}}Response'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Arktype schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Arktype schemas.
            *
···
            *
            * @default '{{name}}Response'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };
···
          *
          * @default 'PascalCase'
          */
-        case: StringCase;
+        case: Casing;
         /**
          * Whether to generate TypeScript types from Arktype schemas.
          *
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Arktype schemas for webhook definitions.
        *
···
        *
        * @default '{{name}}WebhookRequest'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Arktype schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Arktype schemas.
            *
···
            *
            * @default '{{name}}WebhookRequest'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };

packages/openapi-ts/src/plugins/arktype/v2/plugin.ts

···
 
 import { deduplicateSchema } from '~/ir/schema';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import type { SchemaWithType } from '~/plugins/shared/types/schema';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 import { pathToJsonPointer, refToName } from '~/utils/ref';
 
 import { exportAst } from '../shared/export';
···
   const $ref = pathToJsonPointer(fromRef(state.path));
   const ast = irSchemaToAst({ plugin, schema, state });
   const baseName = refToName($ref);
-  const symbol = plugin.registerSymbol({
-    meta: {
-      category: 'schema',
-      path: fromRef(state.path),
-      resource: 'definition',
-      resourceId: $ref,
-      tags: fromRef(state.tags),
-      tool: 'arktype',
+  const symbol = plugin.symbol(
+    applyNaming(baseName, plugin.config.definitions),
+    {
+      meta: {
+        category: 'schema',
+        path: fromRef(state.path),
+        resource: 'definition',
+        resourceId: $ref,
+        tags: fromRef(state.tags),
+        tool: 'arktype',
+      },
     },
-    name: buildName({
-      config: plugin.config.definitions,
-      name: baseName,
-    }),
-  });
+  );
   const typeInferSymbol = plugin.config.definitions.types.infer.enabled
-    ? plugin.registerSymbol({
-        meta: {
-          category: 'type',
-          path: fromRef(state.path),
-          resource: 'definition',
-          resourceId: $ref,
-          tool: 'arktype',
-          variant: 'infer',
+    ? plugin.symbol(
+        applyNaming(baseName, plugin.config.definitions.types.infer),
+        {
+          meta: {
+            category: 'type',
+            path: fromRef(state.path),
+            resource: 'definition',
+            resourceId: $ref,
+            tool: 'arktype',
+            variant: 'infer',
+          },
         },
-        name: buildName({
-          config: plugin.config.definitions.types.infer,
-          name: baseName,
-        }),
-      })
+      )
     : undefined;
   exportAst({
     ast,
···
 };
 
 export const handlerV2: ArktypePlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('type', {
     external: 'arktype',
     meta: {
       category: 'external',
       resource: 'arktype.type',
     },
-    name: 'type',
   });
 
   plugin.forEach(

packages/openapi-ts/src/plugins/fastify/plugin.ts

···
 };
 
 export const handler: FastifyPlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('RouteHandler', {
     external: 'fastify',
     kind: 'type',
     meta: {
···
       resource: 'route-handler',
       tool: 'fastify',
     },
-    name: 'RouteHandler',
   });
 
-  const symbolRouteHandlers = plugin.registerSymbol({
-    name: 'RouteHandlers',
-  });
+  const symbolRouteHandlers = plugin.symbol('RouteHandlers');
 
   const type = $.type.object();
 

packages/openapi-ts/src/plugins/swr/types.d.ts

···
 import type { IR } from '~/ir/types';
 import type { DefinePlugin, Plugin } from '~/plugins';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type UserConfig = Plugin.Name<'swr'> &
   Plugin.Hooks & {
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from SDK functions to the generated SWR code?
      *
···
      */
     infiniteQueryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query key helpers.
            *
···
            *
            * @default '{{name}}InfiniteQueryKey'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in infinite query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     infiniteQueryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate infinite query options helpers.
            *
···
            *
            * @default '{{name}}InfiniteOptions'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated mutation options helpers.
···
      */
     mutationOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate mutation options helpers.
            *
···
            *
            * @default '{{name}}Mutation'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated query keys.
···
      */
     queryKeys?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query keys.
            *
···
            *
            * @default '{{name}}QueryKey'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Whether to include operation tags in query keys.
            * This will make query keys larger but provides better cache invalidation capabilities.
···
      */
     queryOptions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate query options helpers.
            *
···
            *
            * @default '{{name}}Options'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for generated `useSwr()` function helpers.
···
      */
     useSwr?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate `useSwr()` function helpers.
            *
···
            *
            * @default 'use{{name}}'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from SDK functions to the generated SWR code?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query key helpers.
        *
···
        *
        * @default '{{name}}InfiniteQueryKey'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in infinite query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate infinite query options helpers.
        *
···
        *
        * @default '{{name}}InfiniteOptions'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated mutation options helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate mutation options helpers.
        *
···
        *
        * @default '{{name}}Mutation'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Resolved configuration for generated query keys.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query keys.
        *
···
        *
        * @default '{{name}}QueryKey'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Whether to include operation tags in query keys.
        * This will make query keys larger but provides better cache invalidation capabilities.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate query options helpers.
        *
···
        *
        * @default '{{name}}Options'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Configuration for generated `useSwr()` function helpers.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate `useSwr()` function helpers.
        *
···
        *
        * @default 'use{{name}}'
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/swr/v2/plugin.ts

···
 import { createUseSwr } from './useSwr';
 
 export const handlerV2: SwrPlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('useSWR', {
     external: 'swr',
     importKind: 'default',
     kind: 'function',
···
       category: 'external',
       resource: 'swr',
     },
-    name: 'useSWR',
   });
 
   plugin.forEach(

packages/openapi-ts/src/plugins/swr/v2/useSwr.ts

···
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import {
   createOperationComment,
   hasOperationSse,
 } from '~/plugins/shared/utils/operation';
 import type { TsDsl } from '~/ts-dsl';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 
 import type { SwrPlugin } from '../types';
 
···
     category: 'external',
     resource: 'swr',
   });
-  const symbolUseQueryFn = plugin.registerSymbol({
-    name: buildName({
-      config: plugin.config.useSwr,
-      name: operation.id,
-    }),
-  });
+  const symbolUseQueryFn = plugin.symbol(
+    applyNaming(operation.id, plugin.config.useSwr),
+  );
 
   const awaitSdkFn = $.lazy((ctx) =>
     ctx

packages/openapi-ts/src/plugins/valibot/shared/operation.ts

···
 
 import { operationResponsesMap } from '~/ir/operation';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
+import { applyNaming } from '~/utils/naming';
 
 import { exportAst } from './export';
 import type { Ast, IrSchemaToAstOptions } from './types';
···
     schemaData.required = [...requiredProperties];
 
     const ast = getAst(schemaData, fromRef(state.path));
-    const symbol = plugin.registerSymbol({
-      meta: {
-        category: 'schema',
-        path: fromRef(state.path),
-        resource: 'operation',
-        resourceId: operation.id,
-        role: 'data',
-        tags: fromRef(state.tags),
-        tool: 'valibot',
+    const symbol = plugin.symbol(
+      applyNaming(operation.id, plugin.config.requests),
+      {
+        meta: {
+          category: 'schema',
+          path: fromRef(state.path),
+          resource: 'operation',
+          resourceId: operation.id,
+          role: 'data',
+          tags: fromRef(state.tags),
+          tool: 'valibot',
+        },
       },
-      name: buildName({
-        config: plugin.config.requests,
-        name: operation.id,
-      }),
-    });
+    );
     exportAst({
       ast,
       plugin,
···
       if (response) {
         const path = [...fromRef(state.path), 'responses'];
         const ast = getAst(response, path);
-        const symbol = plugin.registerSymbol({
-          meta: {
-            category: 'schema',
-            path,
-            resource: 'operation',
-            resourceId: operation.id,
-            role: 'responses',
-            tags: fromRef(state.tags),
-            tool: 'valibot',
+        const symbol = plugin.symbol(
+          applyNaming(operation.id, plugin.config.responses),
+          {
+            meta: {
+              category: 'schema',
+              path,
+              resource: 'operation',
+              resourceId: operation.id,
+              role: 'responses',
+              tags: fromRef(state.tags),
+              tool: 'valibot',
+            },
           },
-          name: buildName({
-            config: plugin.config.responses,
-            name: operation.id,
-          }),
-        });
+        );
         exportAst({
           ast,
           plugin,

packages/openapi-ts/src/plugins/valibot/shared/webhook.ts

···
 import { fromRef } from '@hey-api/codegen-core';
 
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
+import { applyNaming } from '~/utils/naming';
 
 import { exportAst } from './export';
 import type { Ast, IrSchemaToAstOptions } from './types';
···
     schemaData.required = [...requiredProperties];
 
     const ast = getAst(schemaData, fromRef(state.path));
-    const symbol = plugin.registerSymbol({
-      meta: {
-        category: 'schema',
-        path: fromRef(state.path),
-        resource: 'webhook',
-        resourceId: operation.id,
-        role: 'data',
-        tags: fromRef(state.tags),
-        tool: 'valibot',
+    const symbol = plugin.symbol(
+      applyNaming(operation.id, plugin.config.webhooks),
+      {
+        meta: {
+          category: 'schema',
+          path: fromRef(state.path),
+          resource: 'webhook',
+          resourceId: operation.id,
+          role: 'data',
+          tags: fromRef(state.tags),
+          tool: 'valibot',
+        },
       },
-      name: buildName({
-        config: plugin.config.webhooks,
-        name: operation.id,
-      }),
-    });
+    );
     exportAst({
       ast,
       plugin,

packages/openapi-ts/src/plugins/valibot/types.d.ts

···
 } from '~/plugins/shared/utils/coerce';
 import type { GetIntegerLimit } from '~/plugins/shared/utils/formats';
 import type { $, DollarTsDsl } from '~/ts-dsl';
-import type { StringCase, StringName } from '~/types/case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 import type { IApi } from './api';
 import type { Pipe, PipeResult, PipesUtils } from './shared/pipes';
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from input to the generated Valibot schemas?
      *
···
      */
     definitions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Valibot schemas for reusable definitions.
            *
···
            *
            * @default 'v{{name}}'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Should the exports from the generated files be re-exported in the index
···
      */
     requests?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Valibot schemas for request definitions.
            *
···
            *
            * @default 'v{{name}}Data'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for response-specific Valibot schemas.
···
      */
     responses?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Valibot schemas for response definitions.
            *
···
            *
            * @default 'v{{name}}Response'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * Configuration for webhook-specific Valibot schemas.
···
      */
     webhooks?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Valibot schemas for webhook definitions.
            *
···
            *
            * @default 'v{{name}}WebhookRequest'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
   };
 
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from input to the generated Valibot schemas?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Valibot schemas for reusable definitions.
        *
···
        *
        * @default 'v{{name}}'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Should the exports from the generated files be re-exported in the index
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Valibot schemas for request definitions.
        *
···
        *
        * @default 'v{{name}}Data'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Configuration for response-specific Valibot schemas.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Valibot schemas for response definitions.
        *
···
        *
        * @default 'v{{name}}Response'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * Configuration for webhook-specific Valibot schemas.
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Valibot schemas for webhook definitions.
        *
···
        *
        * @default 'v{{name}}WebhookRequest'
        */
-      name: StringName;
+      name: NameTransformer;
     };
   };
 

packages/openapi-ts/src/plugins/valibot/v1/plugin.ts

···
 
 import { deduplicateSchema } from '~/ir/schema';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import type { SchemaWithType } from '~/plugins';
 import { maybeBigInt } from '~/plugins/shared/utils/coerce';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 import { pathToJsonPointer, refToName } from '~/utils/ref';
 
 import { exportAst } from '../shared/export';
···
   const $ref = pathToJsonPointer(fromRef(state.path));
   const ast = irSchemaToAst({ plugin, schema, state });
   const baseName = refToName($ref);
-  const symbol = plugin.registerSymbol({
-    meta: {
-      category: 'schema',
-      path: fromRef(state.path),
-      resource: 'definition',
-      resourceId: $ref,
-      tags: fromRef(state.tags),
-      tool: 'valibot',
+  const symbol = plugin.symbol(
+    applyNaming(baseName, plugin.config.definitions),
+    {
+      meta: {
+        category: 'schema',
+        path: fromRef(state.path),
+        resource: 'definition',
+        resourceId: $ref,
+        tags: fromRef(state.tags),
+        tool: 'valibot',
+      },
     },
-    name: buildName({
-      config: plugin.config.definitions,
-      name: baseName,
-    }),
-  });
+  );
   exportAst({
     ast,
     plugin,
···
 };
 
 export const handlerV1: ValibotPlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('v', {
     external: 'valibot',
     importKind: 'namespace',
     meta: {
       category: 'external',
       resource: 'valibot.v',
     },
-    name: 'v',
   });
 
   plugin.forEach(

packages/openapi-ts/src/plugins/zod/mini/plugin.ts

···
 
 import { deduplicateSchema } from '~/ir/schema';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import type { SchemaWithType } from '~/plugins';
 import { maybeBigInt } from '~/plugins/shared/utils/coerce';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 import { pathToJsonPointer, refToName } from '~/utils/ref';
 
 import { identifiers } from '../constants';
···
   const $ref = pathToJsonPointer(fromRef(state.path));
   const ast = irSchemaToAst({ plugin, schema, state });
   const baseName = refToName($ref);
-  const symbol = plugin.registerSymbol({
-    meta: {
-      category: 'schema',
-      path: fromRef(state.path),
-      resource: 'definition',
-      resourceId: $ref,
-      tags: fromRef(state.tags),
-      tool: 'zod',
+  const symbol = plugin.symbol(
+    applyNaming(baseName, plugin.config.definitions),
+    {
+      meta: {
+        category: 'schema',
+        path: fromRef(state.path),
+        resource: 'definition',
+        resourceId: $ref,
+        tags: fromRef(state.tags),
+        tool: 'zod',
+      },
     },
-    name: buildName({
-      config: plugin.config.definitions,
-      name: baseName,
-    }),
-  });
+  );
   const typeInferSymbol = plugin.config.definitions.types.infer.enabled
-    ? plugin.registerSymbol({
-        meta: {
-          category: 'type',
-          path: fromRef(state.path),
-          resource: 'definition',
-          resourceId: $ref,
-          tags: fromRef(state.tags),
-          tool: 'zod',
-          variant: 'infer',
+    ? plugin.symbol(
+        applyNaming(baseName, plugin.config.definitions.types.infer),
+        {
+          meta: {
+            category: 'type',
+            path: fromRef(state.path),
+            resource: 'definition',
+            resourceId: $ref,
+            tags: fromRef(state.tags),
+            tool: 'zod',
+            variant: 'infer',
+          },
         },
-        name: buildName({
-          config: plugin.config.definitions.types.infer,
-          name: baseName,
-        }),
-      })
+      )
     : undefined;
   exportAst({
     ast,
···
 };
 
 export const handlerMini: ZodPlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('z', {
     external: getZodModule({ plugin }),
     importKind: 'namespace',
     meta: {
       category: 'external',
       resource: 'zod.z',
     },
-    name: 'z',
   });
 
   plugin.forEach(

packages/openapi-ts/src/plugins/zod/shared/operation.ts

···
 
 import { operationResponsesMap } from '~/ir/operation';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
+import { applyNaming } from '~/utils/naming';
 
 import { exportAst } from './export';
 import type { Ast, IrSchemaToAstOptions } from './types';
···
 
     const ast = getAst(schemaData, fromRef(state.path));
     const symbol = plugin.symbol(
-      buildName({
-        config: plugin.config.requests,
-        name: operation.id,
-      }),
+      applyNaming(operation.id, plugin.config.requests),
       {
         meta: {
           category: 'schema',
···
     );
     const typeInferSymbol = plugin.config.requests.types.infer.enabled
       ? plugin.symbol(
-          buildName({
-            config: plugin.config.requests.types.infer,
-            name: operation.id,
-          }),
+          applyNaming(operation.id, plugin.config.requests.types.infer),
           {
             meta: {
               category: 'type',
···
         const path = [...fromRef(state.path), 'responses'];
         const ast = getAst(response, path);
         const symbol = plugin.symbol(
-          buildName({
-            config: plugin.config.responses,
-            name: operation.id,
-          }),
+          applyNaming(operation.id, plugin.config.responses),
           {
             meta: {
               category: 'schema',
···
         );
         const typeInferSymbol = plugin.config.responses.types.infer.enabled
           ? plugin.symbol(
-              buildName({
-                config: plugin.config.responses.types.infer,
-                name: operation.id,
-              }),
+              applyNaming(operation.id, plugin.config.responses.types.infer),
               {
                 meta: {
                   category: 'type',

packages/openapi-ts/src/plugins/zod/shared/webhook.ts

···
 import { fromRef } from '@hey-api/codegen-core';
 
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
+import { applyNaming } from '~/utils/naming';
 
 import { exportAst } from './export';
 import type { Ast, IrSchemaToAstOptions } from './types';
···
     schemaData.required = [...requiredProperties];
 
     const ast = getAst(schemaData, fromRef(state.path));
-    const symbol = plugin.registerSymbol({
-      meta: {
-        category: 'schema',
-        path: fromRef(state.path),
-        resource: 'webhook',
-        resourceId: operation.id,
-        role: 'data',
-        tags: fromRef(state.tags),
-        tool: 'zod',
+    const symbol = plugin.symbol(
+      applyNaming(operation.id, plugin.config.webhooks),
+      {
+        meta: {
+          category: 'schema',
+          path: fromRef(state.path),
+          resource: 'webhook',
+          resourceId: operation.id,
+          role: 'data',
+          tags: fromRef(state.tags),
+          tool: 'zod',
+        },
       },
-      name: buildName({
-        config: plugin.config.webhooks,
-        name: operation.id,
-      }),
-    });
+    );
     const typeInferSymbol = plugin.config.webhooks.types.infer.enabled
-      ? plugin.registerSymbol({
-          meta: {
-            category: 'type',
-            path: fromRef(state.path),
-            resource: 'webhook',
-            resourceId: operation.id,
-            role: 'data',
-            tags: fromRef(state.tags),
-            tool: 'zod',
-            variant: 'infer',
+      ? plugin.symbol(
+          applyNaming(operation.id, plugin.config.webhooks.types.infer),
+          {
+            meta: {
+              category: 'type',
+              path: fromRef(state.path),
+              resource: 'webhook',
+              resourceId: operation.id,
+              role: 'data',
+              tags: fromRef(state.tags),
+              tool: 'zod',
+              variant: 'infer',
+            },
           },
-          name: buildName({
-            config: plugin.config.webhooks.types.infer,
-            name: operation.id,
-          }),
-        })
+        )
       : undefined;
     exportAst({
       ast,

packages/openapi-ts/src/plugins/zod/types.d.ts

···
 } from '~/plugins/shared/utils/coerce';
 import type { GetIntegerLimit } from '~/plugins/shared/utils/formats';
 import type { $, DollarTsDsl, TsDsl } from '~/ts-dsl';
-import type { StringCase, StringName } from '~/types/case';
 import type { MaybeArray } from '~/types/utils';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 import type { IApi } from './api';
 import type { Chain } from './shared/chain';
···
      *
      * @default 'camelCase'
      */
-    case?: StringCase;
+    case?: Casing;
     /**
      * Add comments from input to the generated Zod schemas?
      *
···
      */
     definitions?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Zod schemas for reusable definitions.
            *
···
            *
            * @default 'z{{name}}'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Zod schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Zod schemas.
                    *
···
                    *
                    * @default '{{name}}ZodType'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
      */
     requests?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Zod schemas for request definitions.
            *
···
            *
            * @default 'z{{name}}Data'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Zod schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Zod schemas.
                    *
···
                    *
                    * @default '{{name}}DataZodType'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
      */
     responses?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Zod schemas for response definitions.
            *
···
            *
            * @default 'z{{name}}Response'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Zod schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Zod schemas.
                    *
···
                    *
                    * @default '{{name}}ResponseZodType'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
        */
       infer?:
         | boolean
-        | StringName
+        | NameTransformer
         | {
             /**
              * The casing convention to use for generated type names.
              *
              * @default 'PascalCase'
              */
-            case?: StringCase;
+            case?: Casing;
             /**
              * Whether to generate TypeScript types from Zod schemas.
              *
···
      */
     webhooks?:
       | boolean
-      | StringName
+      | NameTransformer
       | {
           /**
            * The casing convention to use for generated names.
            *
            * @default 'camelCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to generate Zod schemas for webhook definitions.
            *
···
            *
            * @default 'z{{name}}WebhookRequest'
            */
-          name?: StringName;
+          name?: NameTransformer;
           /**
            * Configuration for TypeScript type generation from Zod schemas.
            *
···
              */
             infer?:
               | boolean
-              | StringName
+              | NameTransformer
               | {
                   /**
                    * The casing convention to use for generated type names.
                    *
                    * @default 'PascalCase'
                    */
-                  case?: StringCase;
+                  case?: Casing;
                   /**
                    * Whether to generate TypeScript types from Zod schemas.
                    *
···
                    *
                    * @default '{{name}}WebhookRequestZodType'
                    */
-                  name?: StringName;
+                  name?: NameTransformer;
                 };
           };
         };
···
      *
      * @default 'camelCase'
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Add comments from input to the generated Zod schemas?
      *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Zod schemas for reusable definitions.
        *
···
        *
        * @default 'z{{name}}'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Zod schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Zod schemas.
            *
···
            *
            * @default '{{name}}ZodType'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Zod schemas for request definitions.
        *
···
        *
        * @default 'z{{name}}Data'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Zod schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Zod schemas.
            *
···
            *
            * @default '{{name}}DataZodType'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Zod schemas for response definitions.
        *
···
        *
        * @default 'z{{name}}Response'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Zod schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Zod schemas.
            *
···
            *
            * @default '{{name}}ResponseZodType'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };
···
          *
          * @default 'PascalCase'
          */
-        case: StringCase;
+        case: Casing;
         /**
          * Whether to generate TypeScript types from Zod schemas.
          *
···
        *
        * @default 'camelCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to generate Zod schemas for webhook definitions.
        *
···
        *
        * @default 'z{{name}}WebhookRequest'
        */
-      name: StringName;
+      name: NameTransformer;
       /**
        * Configuration for TypeScript type generation from Zod schemas.
        *
···
            *
            * @default 'PascalCase'
            */
-          case: StringCase;
+          case: Casing;
           /**
            * Whether to generate TypeScript types from Zod schemas.
            *
···
            *
            * @default '{{name}}WebhookRequestZodType'
            */
-          name: StringName;
+          name: NameTransformer;
         };
       };
     };

packages/openapi-ts/src/plugins/zod/v3/plugin.ts

···
 
 import { deduplicateSchema } from '~/ir/schema';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import type { SchemaWithType } from '~/plugins';
 import { maybeBigInt } from '~/plugins/shared/utils/coerce';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 import { pathToJsonPointer, refToName } from '~/utils/ref';
 
 import { identifiers } from '../constants';
···
   const $ref = pathToJsonPointer(fromRef(state.path));
   const ast = irSchemaToAst({ plugin, schema, state });
   const baseName = refToName($ref);
-  const symbol = plugin.registerSymbol({
-    meta: {
-      category: 'schema',
-      path: fromRef(state.path),
-      resource: 'definition',
-      resourceId: $ref,
-      tags: fromRef(state.tags),
-      tool: 'zod',
+  const symbol = plugin.symbol(
+    applyNaming(baseName, plugin.config.definitions),
+    {
+      meta: {
+        category: 'schema',
+        path: fromRef(state.path),
+        resource: 'definition',
+        resourceId: $ref,
+        tags: fromRef(state.tags),
+        tool: 'zod',
+      },
     },
-    name: buildName({
-      config: plugin.config.definitions,
-      name: baseName,
-    }),
-  });
+  );
   const typeInferSymbol = plugin.config.definitions.types.infer.enabled
-    ? plugin.registerSymbol({
-        meta: {
-          category: 'type',
-          path: fromRef(state.path),
-          resource: 'definition',
-          resourceId: $ref,
-          tags: fromRef(state.tags),
-          tool: 'zod',
-          variant: 'infer',
+    ? plugin.symbol(
+        applyNaming(baseName, plugin.config.definitions.types.infer),
+        {
+          meta: {
+            category: 'type',
+            path: fromRef(state.path),
+            resource: 'definition',
+            resourceId: $ref,
+            tags: fromRef(state.tags),
+            tool: 'zod',
+            variant: 'infer',
+          },
         },
-        name: buildName({
-          config: plugin.config.definitions.types.infer,
-          name: baseName,
-        }),
-      })
+      )
     : undefined;
   exportAst({
     ast,
···
 };
 
 export const handlerV3: ZodPlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('z', {
     external: getZodModule({ plugin }),
     meta: {
       category: 'external',
       resource: 'zod.z',
     },
-    name: 'z',
   });
 
   plugin.forEach(

packages/openapi-ts/src/plugins/zod/v4/plugin.ts

···
 
 import { deduplicateSchema } from '~/ir/schema';
 import type { IR } from '~/ir/types';
-import { buildName } from '~/openApi/shared/utils/name';
 import type { SchemaWithType } from '~/plugins';
 import { maybeBigInt } from '~/plugins/shared/utils/coerce';
 import { $ } from '~/ts-dsl';
+import { applyNaming } from '~/utils/naming';
 import { pathToJsonPointer, refToName } from '~/utils/ref';
 
 import { identifiers } from '../constants';
···
   const $ref = pathToJsonPointer(fromRef(state.path));
   const ast = irSchemaToAst({ plugin, schema, state });
   const baseName = refToName($ref);
-  const symbol = plugin.registerSymbol({
-    meta: {
-      category: 'schema',
-      path: fromRef(state.path),
-      resource: 'definition',
-      resourceId: $ref,
-      tags: fromRef(state.tags),
-      tool: 'zod',
+  const symbol = plugin.symbol(
+    applyNaming(baseName, plugin.config.definitions),
+    {
+      meta: {
+        category: 'schema',
+        path: fromRef(state.path),
+        resource: 'definition',
+        resourceId: $ref,
+        tags: fromRef(state.tags),
+        tool: 'zod',
+      },
     },
-    name: buildName({
-      config: plugin.config.definitions,
-      name: baseName,
-    }),
-  });
+  );
   const typeInferSymbol = plugin.config.definitions.types.infer.enabled
-    ? plugin.registerSymbol({
-        meta: {
-          category: 'type',
-          path: fromRef(state.path),
-          resource: 'definition',
-          resourceId: $ref,
-          tags: fromRef(state.tags),
-          tool: 'zod',
-          variant: 'infer',
+    ? plugin.symbol(
+        applyNaming(baseName, plugin.config.definitions.types.infer),
+        {
+          meta: {
+            category: 'type',
+            path: fromRef(state.path),
+            resource: 'definition',
+            resourceId: $ref,
+            tags: fromRef(state.tags),
+            tool: 'zod',
+            variant: 'infer',
+          },
         },
-        name: buildName({
-          config: plugin.config.definitions.types.infer,
-          name: baseName,
-        }),
-      })
+      )
     : undefined;
   exportAst({
     ast,
···
 };
 
 export const handlerV4: ZodPlugin['Handler'] = ({ plugin }) => {
-  plugin.registerSymbol({
+  plugin.symbol('z', {
     external: getZodModule({ plugin }),
     meta: {
       category: 'external',
       resource: 'zod.z',
     },
-    name: 'z',
   });
 
   plugin.forEach(

packages/openapi-ts/src/types/case.d.ts

···
-export type StringCase =
-  | 'camelCase'
-  | 'PascalCase'
-  | 'preserve'
-  | 'snake_case'
-  | 'SCREAMING_SNAKE_CASE';
-
-export type StringName = string | ((name: string) => string);

packages/openapi-ts/src/types/output.d.ts

···
 import type { NameConflictResolver } from '@hey-api/codegen-core';
 import type ts from 'typescript';
 
-import type { StringCase, StringName } from './case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 export type Formatters = 'biome' | 'prettier';
 
···
    *
    * @default undefined
    */
-  case?: StringCase;
+  case?: Casing;
   /**
    * Clean the `output` folder on every run? If disabled, this folder may
    * be used to store additional files. The default option is `true` to
···
    * @default '{{name}}'
    */
   fileName?:
-    | StringName
+    | NameTransformer
     | {
         /**
          * The casing convention to use for generated file names.
          *
          * @default 'preserve'
          */
-        case?: StringCase;
+        case?: Casing;
         /**
          * Custom naming pattern for generated file names.
          *
          * @default '{{name}}'
          */
-        name?: StringName;
+        name?: NameTransformer;
         /**
          * Suffix to append to file names (before the extension). For example,
          * with a suffix of `.gen`, `example.ts` becomes `example.gen.ts`.
···
    * Defines casing of the output fields. By default, we preserve `input`
    * values as data transforms incur a performance penalty at runtime.
    */
-  case: StringCase | undefined;
+  case: Casing | undefined;
   /**
    * Clean the `output` folder on every run? If disabled, this folder may
    * be used to store additional files. The default option is `true` to
···
     /**
      * The casing convention to use for generated file names.
      */
-    case: StringCase;
+    case: Casing;
     /**
      * Custom naming pattern for generated file names.
      */
-    name: StringName;
+    name: NameTransformer;
     /**
      * Suffix to append to file names (before the extension). For example,
      * with a suffix of `.gen`, `example.ts` becomes `example.gen.ts`.

packages/openapi-ts/src/types/parser.d.ts

···
   OpenApiSchemaObject,
 } from '~/openApi/types';
 import type { Hooks } from '~/parser/types/hooks';
-
-import type { StringCase, StringName } from './case';
+import type { Casing, NameTransformer } from '~/utils/naming';
 
 type EnumsMode = 'inline' | 'root';
 
···
            *
            * @default 'PascalCase'
            */
-          case?: StringCase;
+          case?: Casing;
           /**
            * Whether to transform all enums.
            *
···
            *
            * @default '{{name}}Enum'
            */
-          name?: StringName;
+          name?: NameTransformer;
         };
     /**
      * By default, any object schema with a missing `required` keyword is
···
            * @default '{{name}}Writable'
            */
           requests?:
-            | StringName
+            | NameTransformer
             | {
                 /**
                  * The casing convention to use for generated names.
                  *
                  * @default 'preserve'
                  */
-                case?: StringCase;
+                case?: Casing;
                 /**
                  * Customize the generated name of schemas used in requests or
                  * containing write-only fields.
                  *
                  * @default '{{name}}Writable'
                  */
-                name?: StringName;
+                name?: NameTransformer;
               };
           /**
            * Configuration for generated response-specific schemas.
···
            * @default '{{name}}'
            */
           responses?:
-            | StringName
+            | NameTransformer
             | {
                 /**
                  * The casing convention to use for generated names.
                  *
                  * @default 'preserve'
                  */
-                case?: StringCase;
+                case?: Casing;
                 /**
                  * Customize the generated name of schemas used in responses or
                  * containing read-only fields. We default to the original name
···
                  *
                  * @default '{{name}}'
                  */
-                name?: StringName;
+                name?: NameTransformer;
               };
         };
   };
···
        *
        * @default 'PascalCase'
        */
-      case: StringCase;
+      case: Casing;
       /**
        * Whether to transform all enums.
        *
···
        *
        * @default '{{name}}Enum'
        */
-      name: StringName;
+      name: NameTransformer;
     };
     /**
      * By default, any object schema with a missing `required` keyword is
···
          *
          * @default 'preserve'
          */
-        case: StringCase;
+        case: Casing;
         /**
          * Customize the generated name of schemas used in requests or
          * containing write-only fields.
          *
          * @default '{{name}}Writable'
          */
-        name: StringName;
+        name: NameTransformer;
       };
       /**
        * Configuration for generated response-specific schemas.
···
          *
          * @default 'preserve'
          */
-        case: StringCase;
+        case: Casing;
         /**
          * Customize the generated name of schemas used in responses or
          * containing read-only fields. We default to the original name
···
          *
          * @default '{{name}}'
          */
-        name: StringName;
+        name: NameTransformer;
       };
     };
   };

packages/openapi-ts/src/utils/__tests__/to-case.test.ts packages/openapi-ts/src/utils/naming/__tests__/naming.test.ts

···
 import { describe, expect, it } from 'vitest';
 
-import type { StringCase } from '~/types/case';
+import { toCase } from '../naming';
+import type { Casing } from '../types';
 
-import { toCase } from '../to-case';
-
-const cases: ReadonlyArray<StringCase> = [
+const cases: ReadonlyArray<Casing> = [
   'camelCase',
   'PascalCase',
   'SCREAMING_SNAKE_CASE',

packages/openapi-ts/src/utils/exports.ts

···
-import type { StringCase } from '~/types/case';
-
-import { toCase } from './to-case';
+import type { Casing } from './naming';
+import { toCase } from './naming';
 
 /**
  * Utilities shared across the package.
···
     stripLeadingSeparators,
     value,
   }: {
-    readonly case: StringCase | undefined;
+    readonly case: Casing | undefined;
     /**
      * If leading separators have a semantic meaning, we might not want to
      * remove them.

packages/openapi-ts/src/utils/naming/index.ts

···
+export { applyNaming, resolveNaming, toCase } from './naming';
+export type {
+  Casing,
+  NameTransformer,
+  NamingConfig,
+  NamingRule,
+} from './types';

packages/openapi-ts/src/utils/naming/types.d.ts

···
+/**
+ * Available casing strategies.
+ */
+export type Casing =
+  | 'camelCase'
+  | 'PascalCase'
+  | 'preserve'
+  | 'snake_case'
+  | 'SCREAMING_SNAKE_CASE';
+
+/**
+ * Name transformer: template string or function.
+ *
+ * Template supports `{{name}}` variable.
+ */
+export type NameTransformer = string | ((name: string) => string);
+
+/**
+ * Full naming configuration.
+ */
+export interface NamingConfig {
+  /**
+   * Casing strategy applied after transformation.
+   *
+   * @deprecated Use `casing` instead.
+   */
+  case?: Casing;
+  /**
+   * Casing strategy applied after transformation.
+   */
+  casing?: Casing;
+  /**
+   * Name template or transformer function.
+   *
+   * Applied before `casing` transformation.
+   */
+  name?: NameTransformer;
+}
+
+/**
+ * Name customization: shorthand or full configuration.
+ */
+export type NamingRule = NameTransformer | NamingConfig;

packages/openapi-ts/src/utils/to-case.ts packages/openapi-ts/src/utils/naming/naming.ts

···
-import type { StringCase } from '~/types/case';
+import type { Casing, NamingConfig, NamingRule } from './types';
 
 const uppercaseRegExp = /[\p{Lu}]/u;
 const lowercaseRegExp = /[\p{Ll}]/u;
···
   'gu',
 );
 
-const preserveCase = (value: string, casing: StringCase) => {
+const preserveCase = (value: string, casing: Casing) => {
   let isLastCharLower = false;
   let isLastCharUpper = false;
   let isLastLastCharUpper = false;
···
 };
 
 /**
- * Converts the given string to the specified casing.
+ * Convert a string to the specified casing.
  *
  * @param value - The string to convert
  * @param casing - The target casing
···
  */
 export const toCase = (
   value: string,
-  casing: StringCase | undefined,
+  casing: Casing | undefined,
   options: {
     /**
      * If leading separators have a semantic meaning, we might not want to
···
 
   return result;
 };
+
+/**
+ * Normalize a NamingRule to NamingConfig.
+ */
+export function resolveNaming(rule: NamingRule | undefined): NamingConfig {
+  if (!rule) {
+    return {};
+  }
+  if (typeof rule === 'string' || typeof rule === 'function') {
+    return { name: rule };
+  }
+  return rule;
+}
+
+/**
+ * Apply naming configuration to a value.
+ *
+ * Casing is applied first, then transformation.
+ */
+export function applyNaming(value: string, config: NamingConfig): string {
+  let result = value;
+
+  const casing = config.casing ?? config.case;
+
+  if (config.name) {
+    if (typeof config.name === 'function') {
+      result = config.name(result);
+    } else {
+      // TODO: refactor so there's no need for separators?
+      const separator = casing === 'preserve' ? '' : '-';
+      result = config.name.replace(
+        '{{name}}',
+        `${separator}${result}${separator}`,
+      );
+    }
+  }
+
+  // TODO: apply case before name?
+  return toCase(result, casing);
+}

pnpm-lock.yaml

···
 
   dev:
     devDependencies:
+      '@angular/common':
+        specifier: 19.2.17
+        version: 19.2.17(@angular/core@19.2.17(rxjs@7.8.2)(zone.js@0.16.0))(rxjs@7.8.2)
+      '@angular/core':
+        specifier: 19.2.17
+        version: 19.2.17(rxjs@7.8.2)(zone.js@0.16.0)
       '@hey-api/codegen-core':
         specifier: workspace:*
         version: link:../packages/codegen-core