@kubb/plugin-ts 5.0.0-beta.10 → 5.0.0-beta.100

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import * as _$_kubb_core0 from "@kubb/core";
-import { Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
+import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
+import { KubbReactNode } from "kubb/jsx";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
 import ts from "typescript";
-import { KubbReactNode } from "@kubb/renderer-jsx/types";
-
+import "@kubb/adapter-oas";
 //#region src/printers/printerTs.d.ts
 /**
  * Partial map of node-type overrides for the TypeScript printer.
@@ -44,23 +43,11 @@ type PrinterTsOptions = {
    */
   arrayType: PluginTs['resolvedOptions']['arrayType'];
   /**
-   * Enum output format.
-   * - `'inlineLiteral'` embeds literal unions inline
-   * - `'asPascalConst'` generates named const unions
-   * - `'asConst'` generates as const declarations
-   *
-   * @default `'inlineLiteral'`
+   * Grouped enum settings. The printer emits references to enums, not the enum declarations, so only
+   * `type` (the output format) and `typeSuffix` (the enum key reference suffix) matter here.
+   * `constCasing` and `keyCasing` are ignored.
    */
-  enumType: PluginTs['resolvedOptions']['enumType'];
-  /**
-   * Suffix appended to enum key reference names.
-   *
-   * @example Enum key naming
-   * `StatusKey` when `enumType` is `'asConst'`
-   *
-   * @default `'Key'`
-   */
-  enumTypeSuffix?: PluginTs['resolvedOptions']['enumTypeSuffix'];
+  enum: PluginTs['resolvedOptions']['enum'];
   /**
    * Syntax for generated declarations.
    * - `'type'` generates type aliases
@@ -82,7 +69,7 @@ type PrinterTsOptions = {
    * Properties to exclude using `Omit<Type, Keys>`.
    * Forces type alias syntax regardless of `syntaxType` setting.
    */
-  keysToOmit?: Array<string>;
+  keysToOmit?: Array<string> | null;
   /**
    * Transforms raw schema names into valid TypeScript identifiers.
    */
@@ -113,13 +100,13 @@ type PrinterTsFactory = ast.PrinterFactoryOptions<'typescript', PrinterTsOptions
  *
  * @example Raw type node (no `typeName`)
  * ```ts
- * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral' })
+ * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })
  * const typeNode = printer.print(schemaNode) // ts.TypeNode
  * ```
  *
  * @example Full declaration (with `typeName`)
  * ```ts
- * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral', typeName: 'MyType' })
+ * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })
  * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
  * ```
  */
@@ -128,122 +115,148 @@ declare const printerTs: (options?: PrinterTsOptions | undefined) => ast.Printer
 //#region src/types.d.ts
 /**
  * The concrete resolver type for `@kubb/plugin-ts`.
- * Extends the base `Resolver` (which provides `default` and `resolveOptions`) with
- * plugin-specific naming helpers for operations, parameters, responses, and schemas.
+ * Extends the base `Resolver` (which provides `default` naming and option helpers, the top-level
+ * `name` casing, and the `file` builder) with plugin-specific naming namespaces for operation
+ * parameters, responses, and enum schemas.
  */
-type ResolverTs = Resolver & ast.OperationParamsResolver & {
-  /**
-   * Resolves the name for a given raw name (equivalent to `default(name, 'function')`).
-   * Since TypeScript only emits types, this is the canonical naming method.
-   *
-   * @example Resolving type names
-   * `resolver.resolveName('list pets status 200') // → 'ListPetsStatus200'`
-   */
-  resolveTypeName(name: string): string;
-  /**
-   * Resolves the file/path name for a given identifier using PascalCase.
-   *
-   * @example Resolving path names
-   * `resolver.resolvePathName('list pets', 'file') // → 'ListPets'`
-   */
-  resolvePathName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  /**
-   * Resolves the request body type name for an operation (required on ResolverTs).
-   */
-  resolveDataName(node: ast.OperationNode): string;
-  /**
-   * Resolves the name for an operation response by status code.
-   * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
-   *
-   * @example Response status names
-   * `resolver.resolveResponseStatusName(node, 200) // → 'ListPetsStatus200'`
-   */
-  resolveResponseStatusName(node: ast.OperationNode, statusCode: ast.StatusCode): string;
-  /**
-   * Resolves the name for an operation's request config (`RequestConfig`).
-   *
-   * @example Request config names
-   * `resolver.resolveRequestConfigName(node) // → 'ListPetsRequestConfig'`
-   */
-  resolveRequestConfigName(node: ast.OperationNode): string;
-  /**
-   * Resolves the name for the collection of all operation responses (`Responses`).
-   *
-   * @example Responses collection names
-   * `resolver.resolveResponsesName(node) // → 'ListPetsResponses'`
-   */
-  resolveResponsesName(node: ast.OperationNode): string;
-  /**
-   * Resolves the name for the union of all operation responses (`Response`).
-   *
-   * @example Response union names
-   * `resolver.resolveResponseName(node) // → 'ListPetsResponse'`
-   */
-  resolveResponseName(node: ast.OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an enum schema's key variant.
-   * Appends `enumTypeSuffix` (default `'Key'`) after applying the default naming convention.
-   *
-   * @example Enum key names with different suffixes
-   * ```ts
-   * resolver.resolveEnumKeyName(node, 'Key')   // → 'PetStatusKey'
-   * resolver.resolveEnumKeyName(node, 'Value') // → 'PetStatusValue'
-   * resolver.resolveEnumKeyName(node, '')      // → 'PetStatus'
-   * ```
-   */
-  resolveEnumKeyName(node: {
-    name?: string | null;
-  }, enumTypeSuffix: string): string;
-  /**
-   * Resolves the name for an operation's grouped path parameters type.
-   *
-   * @example Path parameters names
-   * `resolver.resolvePathParamsName(node, param) // → 'GetPetByIdPathParams'`
-   */
-  resolvePathParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
+type ResolverTs = Resolver & {
+  /**
+   * Naming for an operation's parameters, grouped by location.
+   */
+  param: {
+    /**
+     * Resolves the type name for an individual parameter.
+     *
+     * @example Individual parameter name
+     * `resolver.param.name(node, param) // → 'DeletePetPathPetId'`
+     */
+    name(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the name for an operation's grouped path parameters type.
+     *
+     * @example Path parameters names
+     * `resolver.param.path(node, param) // → 'GetPetByIdPath'`
+     */
+    path(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the name for an operation's grouped query parameters type.
+     *
+     * @example Query parameters names
+     * `resolver.param.query(node, param) // → 'FindPetsByStatusQuery'`
+     */
+    query(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the name for an operation's grouped header parameters type.
+     *
+     * @example Header parameters names
+     * `resolver.param.headers(node, param) // → 'DeletePetHeaders'`
+     */
+    headers(node: ast.OperationNode, param: ast.ParameterNode): string;
+  };
   /**
-   * Resolves the name for an operation's grouped query parameters type.
-   *
-   * @example Query parameters names
-   * `resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'`
-   */
-  resolveQueryParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
+   * Naming for an operation's request and response types.
+   */
+  response: {
+    /**
+     * Resolves the name for an operation response by status code.
+     * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
+     *
+     * @example Response status names
+     * `resolver.response.status(node, 200) // → 'ListPetsStatus200'`
+     */
+    status(node: ast.OperationNode, statusCode: ast.StatusCode): string;
+    /**
+     * Resolves the name for an operation's grouped request options type (`Options`), the
+     * `{ body, path, query, headers }` bag passed to call an operation.
+     *
+     * @example Options type names
+     * `resolver.response.options(node) // → 'ListPetsOptions'`
+     */
+    options(node: ast.OperationNode): string;
+    /**
+     * Resolves the name for the collection of all operation responses (`Responses`).
+     *
+     * @example Responses collection names
+     * `resolver.response.responses(node) // → 'ListPetsResponses'`
+     */
+    responses(node: ast.OperationNode): string;
+    /**
+     * Resolves the name for the union of all operation responses (`Response`).
+     *
+     * @example Response union names
+     * `resolver.response.response(node) // → 'ListPetsResponse'`
+     */
+    response(node: ast.OperationNode): string;
+    /**
+     * Resolves the request body type name.
+     *
+     * @example Request body type name
+     * `resolver.response.body(node) // → 'CreatePetBody'`
+     */
+    body(node: ast.OperationNode): string;
+  };
   /**
-   * Resolves the name for an operation's grouped header parameters type.
-   *
-   * @example Header parameters names
-   * `resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'`
-   */
-  resolveHeaderParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
+   * Naming for enum schemas.
+   */
+  enum: {
+    /**
+     * Resolves the TypeScript type alias name for an enum schema's key variant.
+     * Appends `enumTypeSuffix` (default `'key'`) after applying the default naming convention.
+     *
+     * @example Enum key names with different suffixes
+     * ```ts
+     * resolver.enum.keyName(node, 'Key')   // → 'PetStatusKey'
+     * resolver.enum.keyName(node, 'Value') // → 'PetStatusValue'
+     * resolver.enum.keyName(node, '')      // → 'PetStatus'
+     * ```
+     */
+    keyName(node: {
+      name?: string | null;
+    }, enumTypeSuffix?: string): string;
+  };
 };
 type EnumKeyCasing = 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none';
+type EnumConstCasing = 'camelCase' | 'pascalCase';
 /**
- * Discriminated union that ties `enumTypeSuffix` and `enumKeyCasing` to the enum types that actually use them.
- *
- * - `'asConst'` / `'asPascalConst'` — emit a `const` object; both `enumTypeSuffix` (type-alias suffix) and
- *    `enumKeyCasing` (key formatting) are meaningful.
- * - `'enum'` / `'constEnum'` — emit a TypeScript enum; `enumKeyCasing` applies to member names,
- *    but there is no separate type alias so `enumTypeSuffix` is not used.
- * - `'literal'` / `'inlineLiteral'` — emit only union literals; keys are discarded entirely,
- *    so neither `enumTypeSuffix` nor `enumKeyCasing` have any effect.
+ * Grouped enum settings. Each `type` uses only some of the other fields.
+ *
+ * - `'asConst'` emits a `const` object plus a `typeof` type alias, so `constCasing`, `typeSuffix`, and `keyCasing` all apply.
+ * - `'enum'` and `'constEnum'` emit a TypeScript enum, so only `keyCasing` (the member names) applies.
+ * - `'literal'` and `'inlineLiteral'` emit union literals and drop the keys, so none of the other fields apply.
+ *
+ * @example Share one name between the const and the type
+ * ```ts
+ * enum: { type: 'asConst', constCasing: 'pascalCase', typeSuffix: '' }
+ * // export const VehicleType = { … } as const
+ * // export type VehicleType = (typeof VehicleType)[keyof typeof VehicleType]
+ * ```
  */
-type EnumTypeOptions = {
+type EnumOptions$1 = {
   /**
-   * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-   * - 'asConst' generates const objects with camelCase names and as const assertion.
-   * - 'asPascalConst' generates const objects with PascalCase names and as const assertion.
+   * Emit a `const` object asserted with `as const`, paired with a `typeof` type alias.
+   * This is tree-shakeable and adds no enum runtime.
+   *
    * @default 'asConst'
    */
-  enumType?: 'asConst' | 'asPascalConst';
+  type?: 'asConst';
   /**
-   * Suffix appended to the generated type alias name.
+   * Casing of the generated const variable.
+   * - 'camelCase' names the const `vehicleType`.
+   * - 'pascalCase' names the const `VehicleType`, matching the schema name.
    *
-   * Only affects the type alias — the const object name is unchanged.
+   * @default 'camelCase'
+   */
+  constCasing?: EnumConstCasing;
+  /**
+   * Suffix appended to the generated type alias name. Only the type alias is renamed. The const
+   * object name stays the same. Set it to `''` together with `constCasing: 'pascalCase'` to merge
+   * the const and type under the schema's exact name.
    *
    * @default 'Key'
-   * @example enumTypeSuffix: 'Value' → `export type PetStatusValue = …`
+   * @example A custom suffix
+   * `typeSuffix: 'Value'` renames the alias to `PetStatusValue`
    */
-  enumTypeSuffix?: string;
+  typeSuffix?: string;
   /**
    * Choose the casing for enum key names.
    * - 'screamingSnakeCase' generates keys in SCREAMING_SNAKE_CASE format.
@@ -253,22 +266,24 @@ type EnumTypeOptions = {
    * - 'none' uses the enum value as-is without transformation.
    * @default 'none'
    */
-  enumKeyCasing?: EnumKeyCasing;
+  keyCasing?: EnumKeyCasing;
 } | {
   /**
-   * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-   * - 'enum' generates TypeScript enum declarations.
-   * - 'constEnum' generates TypeScript const enum declarations.
+   * Emit a TypeScript `enum` (`'enum'`) or `const enum` (`'constEnum'`) declaration.
+   *
    * @default 'asConst'
    */
-  enumType?: 'enum' | 'constEnum';
+  type?: 'enum' | 'constEnum';
   /**
-   * `enumTypeSuffix` has no effect for this `enumType`.
-   * It is only used when `enumType` is `'asConst'` or `'asPascalConst'`.
+   * `constCasing` has no effect for this `type`. Only `'asConst'` emits a const object.
    */
-  enumTypeSuffix?: never;
+  constCasing?: never;
   /**
-   * Choose the casing for enum key names.
+   * `typeSuffix` has no effect for this `type`. Only `'asConst'` emits a separate type alias.
+   */
+  typeSuffix?: never;
+  /**
+   * Choose the casing for enum member names.
    * - 'screamingSnakeCase' generates keys in SCREAMING_SNAKE_CASE format.
    * - 'snakeCase' generates keys in snake_case format.
    * - 'pascalCase' generates keys in PascalCase format.
@@ -276,119 +291,111 @@ type EnumTypeOptions = {
    * - 'none' uses the enum value as-is without transformation.
    * @default 'none'
    */
-  enumKeyCasing?: EnumKeyCasing;
+  keyCasing?: EnumKeyCasing;
 } | {
   /**
-   * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-   * - 'literal' generates literal union types.
-   * - 'inlineLiteral' will inline enum values directly into the type (default in v5).
+   * Emit a union of literals as a named alias (`'literal'`) or inline the union at every usage
+   * site (`'inlineLiteral'`).
+   *
    * @default 'asConst'
    * @note In Kubb v5, 'inlineLiteral' becomes the default.
    */
-  enumType?: 'literal' | 'inlineLiteral';
+  type?: 'literal' | 'inlineLiteral';
   /**
-   * `enumTypeSuffix` has no effect for this `enumType`.
-   * It is only used when `enumType` is `'asConst'` or `'asPascalConst'`.
+   * `constCasing` has no effect for this `type`; literal modes emit no const object.
    */
-  enumTypeSuffix?: never;
+  constCasing?: never;
   /**
-   * `enumKeyCasing` has no effect for this `enumType`.
-   * Literal and inlineLiteral modes emit only values — keys are discarded entirely.
+   * `typeSuffix` has no effect for this `type`; literal modes emit no separate type alias.
    */
-  enumKeyCasing?: never;
-};
-type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'types', barrelType: 'named' }
-   */
-  output?: Output;
+  typeSuffix?: never;
   /**
-   * Define which contentType should be used.
-   * By default, uses the first valid JSON media type.
+   * `keyCasing` has no effect for this `type`. Literal and inlineLiteral modes emit only values,
+   * so the keys are discarded.
    */
-  contentType?: 'application/json' | (string & {});
-  /**
-   * Group the clients based on the provided name.
-   */
-  group?: Group;
+  keyCasing?: never;
+};
+/**
+ * Where the generated `.ts` files are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'types', barrel: { type: 'named' } }
+ */
+type Options = OutputOptions & {
   /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   * Skip operations matching at least one entry in the list.
    */
   exclude?: Array<Exclude>;
   /**
-   * Array containing include parameters to include tags/operations/methods/paths.
+   * Restrict generation to operations matching at least one entry in the list.
    */
   include?: Array<Include>;
   /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   * Apply a different options object to operations matching a pattern.
    */
   override?: Array<Override<ResolvedOptions>>;
   /**
-   * Switch between type or interface for creating TypeScript types.
-   * - 'type' generates type alias declarations.
-   * - 'interface' generates interface declarations.
+   * Whether object schemas are emitted as `type` aliases or `interface` declarations.
+   * - `'type'` emits closed type aliases. Safer default for generated code.
+   * - `'interface'` emits interfaces. Useful when consumers rely on declaration merging.
+   *
    * @default 'type'
+   * @see https://www.totaltypescript.com/type-vs-interface-which-should-you-use
    */
   syntaxType?: 'type' | 'interface';
   /**
-   * Choose what to use as mode for an optional value.
-   * - 'questionToken' marks the property as optional with ? (e.g., type?: string).
-   * - 'undefined' adds undefined to the type union (e.g., type: string | undefined).
-   * - 'questionTokenAndUndefined' combines both approaches (e.g., type?: string | undefined).
+   * How optional properties are written in generated types.
+   * - `'questionToken'` — `type?: string`. The property may be missing.
+   * - `'undefined'` — `type: string | undefined`. Required to exist, may be `undefined`.
+   * - `'questionTokenAndUndefined'` — `type?: string | undefined`. Strictest.
+   *
    * @default 'questionToken'
+   * @note Pick `'questionTokenAndUndefined'` when `exactOptionalPropertyTypes` is on in `tsconfig.json`.
    */
   optionalType?: 'questionToken' | 'undefined' | 'questionTokenAndUndefined';
   /**
-   * Choose between Array<string> or string[] for array types.
-   * - 'generic' generates Array<Type> syntax.
-   * - 'array' generates Type[] syntax.
+   * Syntax used for array types.
+   * - `'array'` — `Type[]`. Shorter.
+   * - `'generic'` — `Array<Type>`. More readable for complex element types.
+   *
    * @default 'array'
    */
   arrayType?: 'generic' | 'array';
   /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelCase for pathParams, queryParams and headerParams property names
-   * @default undefined
-   * @note response types (data/body) are NOT affected by this option
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * Define some generators next to the ts generators
-   */
-  generators?: Array<Generator<PluginTs>>;
-  /**
-   * Override naming conventions. When a method returns `null` or `undefined`, the preset
-   * resolver (`resolverTs`) is used as fallback.
+   * Override how names and file paths are built for generated symbols.
+   * Methods you omit fall back to the default `resolverTs`. `this` is bound to the
+   * full resolver, so `this.default.name(name)` delegates to the built-in implementation.
    */
-  resolver?: Partial<ResolverTs> & ThisType<ResolverTs>;
+  resolver?: ResolverPatch<ResolverTs>;
   /**
-   * AST visitor applied to each schema/operation node before printing.
-   * Returning `null` or `undefined` from a visitor method falls back to the preset transformer.
+   * Macros applied to each schema or operation node before printing.
+   * Callbacks you omit fall back to the preset behavior.
    *
-   * @example Remove writeOnly properties from response types
+   * @example Drop writeOnly properties from response types
    * ```ts
-   * transformer: {
-   *   property(node) {
-   *     if (node.schema.writeOnly) return undefined
-   *   }
-   * }
+   * macros: [
+   *   {
+   *     name: 'drop-write-only',
+   *     property(node) {
+   *       if (node.schema.writeOnly) return undefined
+   *     },
+   *   },
+   * ]
    * ```
    */
-  transformer?: ast.Visitor;
+  macros?: Array<ast.Macro>;
   /**
-   * Override individual printer node handlers to customize rendering of specific schema types.
-   *
-   * Each key is a `SchemaType` (e.g. `'date'`, `'string'`). The function replaces the
-   * built-in handler for that type. Use `this.transform` to recurse into nested schema nodes.
+   * Replace the TypeScript handler for a specific schema type (`'integer'`, `'date'`, ...).
+   * Each handler returns a TypeScript AST node for that schema type. Use `this.transform`
+   * to recurse into nested schema nodes.
    *
-   * @example Override the `date` node to use the `Date` object type
+   * @example Use the JavaScript `Date` object for date schemas
    * ```ts
    * import ts from 'typescript'
    * pluginTs({
    *   printer: {
    *     nodes: {
-   *       date(node) {
+   *       date() {
    *         return ts.factory.createTypeReferenceNode('Date', [])
    *       },
    *     },
@@ -399,20 +406,27 @@ type Options = {
   printer?: {
     nodes?: PrinterTsNodes;
   };
-} & EnumTypeOptions;
+  /**
+   * How OpenAPI enums are represented in the generated TypeScript, and how their names are cased.
+   */
+  enum?: EnumOptions$1;
+};
+type ResolvedEnumOptions = {
+  type: NonNullable<EnumOptions$1['type']>;
+  constCasing: EnumConstCasing;
+  typeSuffix: string;
+  keyCasing: EnumKeyCasing;
+};
 type ResolvedOptions = {
   output: Output;
   exclude: Array<Exclude>;
   include: Array<Include> | undefined;
   override: Array<Override<ResolvedOptions>>;
-  group: Group | undefined;
-  enumType: NonNullable<Options['enumType']>;
-  enumTypeSuffix: NonNullable<Options['enumTypeSuffix']>;
-  enumKeyCasing: EnumKeyCasing;
+  group: Group | null;
+  enum: ResolvedEnumOptions;
   optionalType: NonNullable<Options['optionalType']>;
   arrayType: NonNullable<Options['arrayType']>;
   syntaxType: NonNullable<Options['syntaxType']>;
-  paramsCasing: Options['paramsCasing'];
   printer: Options['printer'];
 };
 type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, ResolverTs>;
@@ -425,39 +439,25 @@ declare global {
 }
 //#endregion
 //#region src/components/Enum.d.ts
+type EnumOptions = PluginTs['resolvedOptions']['enum'];
 type Props$1 = {
   node: ast.EnumSchemaNode;
-  enumType: PluginTs['resolvedOptions']['enumType'];
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix'];
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing'];
+  enum: EnumOptions;
   resolver: ResolverTs;
   key?: string | number | null;
 };
-/**
- * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
- *
- * The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
- * valid TypeScript identifier. The resolver normalizes it; for inline enum
- * properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.
- */
 /**
  * Renders the enum declaration(s) for a single named `EnumSchemaNode`.
  *
- * Depending on `enumType` this may emit:
- * - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
+ * Depending on `enum.type` this may emit:
+ * - A runtime object (`asConst`) plus a `typeof` type alias
  * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
  * - A union literal type alias (`literal`)
  *
  * The emitted `File.Source` nodes carry the resolved names so that the barrel
  * index picks up the correct export identifiers.
  */
-declare function Enum({
-  node,
-  enumType,
-  enumTypeSuffix,
-  enumKeyCasing,
-  resolver
-}: Props$1): KubbReactNode;
+declare function Enum({ node, enum: enumOptions, resolver }: Props$1): KubbReactNode;
 //#endregion
 //#region src/components/Type.d.ts
 type Props = {
@@ -468,60 +468,275 @@ type Props = {
    * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.
    */
   printer: ast.Printer<PrinterTsFactory>;
-  enumType: PluginTs['resolvedOptions']['enumType'];
-  enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix'];
-  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing'];
+  enum: PluginTs['resolvedOptions']['enum'];
   resolver: ResolverTs;
 };
-declare function Type({
-  name,
-  node,
-  printer,
-  enumType,
-  enumTypeSuffix,
-  enumKeyCasing,
-  resolver
-}: Props): KubbReactNode;
+declare function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode;
 //#endregion
 //#region src/generators/typeGenerator.d.ts
-declare const typeGenerator: _$_kubb_core0.Generator<PluginTs, unknown>;
+/**
+ * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
+ * schema in the spec plus per-operation request, response, and parameter
+ * types. Drop-replace with a custom `Generator<PluginTs>` to change how
+ * TypeScript output is produced.
+ */
+declare const typeGenerator: import("kubb/kit").Generator<PluginTs, unknown>;
 //#endregion
 //#region src/plugin.d.ts
 /**
- * Canonical plugin name for `@kubb/plugin-ts`, used to identify the plugin in driver lookups and warnings.
+ * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and
+ * cross-plugin dependency references.
  */
 declare const pluginTsName = "plugin-ts";
 /**
- * The `@kubb/plugin-ts` plugin factory.
- *
- * Generates TypeScript type declarations from an OpenAPI/AST `RootNode`.
- * Walks schemas and operations, delegates rendering to the active generators,
- * and writes barrel files based on `output.barrelType`.
+ * Generates TypeScript `type` aliases and `interface` declarations from an
+ * OpenAPI spec. The foundation that every other Kubb plugin builds on:
+ * clients, query hooks, mocks, and validators all reference the names this
+ * plugin produces.
  *
  * @example
  * ```ts
- * import pluginTs from '@kubb/plugin-ts'
+ * import { defineConfig } from 'kubb/config'
+ * import { pluginTs } from '@kubb/plugin-ts'
  *
  * export default defineConfig({
- *   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs({
+ *       output: { path: './types' },
+ *       enum: { type: 'asConst' },
+ *       optionalType: 'questionTokenAndUndefined',
+ *     }),
+ *   ],
  * })
  * ```
  */
-declare const pluginTs: (options?: Options | undefined) => _$_kubb_core0.Plugin<PluginTs>;
+declare const pluginTs: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginTs>;
+//#endregion
+//#region src/printers/functionParams.d.ts
+/**
+ * A type expression used as a function parameter type annotation.
+ *
+ * - a plain `string` is a type reference rendered as-is, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`
+ * - a {@link TypeLiteralNode} is an inline anonymous type, e.g. `{ petId: string; name?: string }`
+ * - an {@link IndexedAccessTypeNode} is a single field accessed from a named type, e.g. `PathParams['petId']`
+ */
+type TypeExpression = string | TypeLiteralNode | IndexedAccessTypeNode;
+/**
+ * An inline anonymous object type grouping named fields.
+ * Renders as `{ key: Type; other?: OtherType }`.
+ */
+type TypeLiteralNode = {
+  kind: 'TypeLiteral';
+  /**
+   * Members of the object type, rendered in order.
+   */
+  members: Array<{
+    /**
+     * Member key.
+     */
+    name: string;
+    /**
+     * Member type expression.
+     */
+    type: TypeExpression;
+    /**
+     * Whether the member is optional, rendered with `?`.
+     */
+    optional?: boolean;
+  }>;
+};
+/**
+ * A single field accessed from a named group type. Renders as `target['key']`.
+ */
+type IndexedAccessTypeNode = {
+  kind: 'IndexedAccessType';
+  /**
+   * Name of the type being indexed, e.g. `'GetPetPathParams'`.
+   */
+  target: string;
+  /**
+   * Field key to access, e.g. `'petId'`.
+   */
+  key: string;
+};
+/**
+ * An object destructuring binding, used as the name of a grouped function parameter.
+ * Renders as `{ id, name }` or `{ id: renamed }` when `propertyName` differs.
+ */
+type ObjectBindingPatternNode = {
+  kind: 'ObjectBindingPattern';
+  /**
+   * Bound elements, rendered in order.
+   */
+  elements: Array<{
+    /**
+     * Local binding name.
+     */
+    name: string;
+    /**
+     * Source key when it differs from the binding name, rendered as `propertyName: name`.
+     */
+    propertyName?: string;
+  }>;
+};
+/**
+ * One function parameter.
+ *
+ * A simple parameter has a `string` name. A destructured group has an
+ * {@link ObjectBindingPatternNode} name paired with a {@link TypeLiteralNode} type.
+ *
+ * @example Required parameter
+ * `name: Type`
+ *
+ * @example Optional parameter
+ * `name?: Type`
+ *
+ * @example Parameter with default value
+ * `name: Type = defaultValue`
+ *
+ * @example Rest parameter
+ * `...name: Type[]`
+ *
+ * @example Destructured group
+ * `{ id, name? }: { id: string; name?: string } = {}`
+ */
+type FunctionParameterNode = {
+  kind: 'FunctionParameter';
+  /**
+   * Parameter name, or an {@link ObjectBindingPatternNode} for a destructured group.
+   */
+  name: string | ObjectBindingPatternNode;
+  /**
+   * Type annotation as a {@link TypeExpression}. Omit for untyped output.
+   */
+  type?: TypeExpression;
+  /**
+   * Whether the parameter is optional, rendered with `?`.
+   */
+  optional?: boolean;
+  /**
+   * Default value, written verbatim after `=`. Commonly `'{}'` for a destructured group.
+   */
+  default?: string;
+  /**
+   * When `true` the parameter is emitted as a rest parameter, e.g. `...name: Type[]`.
+   */
+  rest?: boolean;
+};
+/**
+ * A complete function parameter list.
+ *
+ * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
+ */
+type FunctionParametersNode = {
+  kind: 'FunctionParameters';
+  /**
+   * Ordered parameter nodes.
+   */
+  params: ReadonlyArray<FunctionParameterNode>;
+};
+/**
+ * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
+ *
+ * @example
+ * ```ts
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
+ * ```
+ */
+declare function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLiteralNode;
+/**
+ * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+ *
+ * @example
+ * ```ts
+ * createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })
+ * // DeletePetPathParams['petId']
+ * ```
+ */
+declare function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kind'>): IndexedAccessTypeNode;
+/**
+ * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+ *
+ * @example
+ * ```ts
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
+ * ```
+ */
+declare function createObjectBindingPattern(props: Omit<ObjectBindingPatternNode, 'kind'>): ObjectBindingPatternNode;
+/**
+ * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.
+ */
+type FunctionParameterProperty = {
+  name: string;
+  type: TypeExpression;
+  optional?: boolean;
+};
+type FunctionParameterInput = {
+  name: string | ObjectBindingPatternNode;
+  type?: TypeExpression;
+  optional?: boolean;
+  default?: string;
+  rest?: boolean;
+} | {
+  properties: Array<FunctionParameterProperty>;
+  optional?: boolean;
+  default?: string;
+};
+/**
+ * Creates a {@link FunctionParameterNode}. `optional` defaults to `false`.
+ * Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+ * paired with a {@link TypeLiteralNode} type.
+ *
+ * @example Optional param
+ * ```ts
+ * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+ * // → params?: QueryParams
+ * ```
+ *
+ * @example Destructured group
+ * ```ts
+ * createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+ * // → { id, name }: { id: string; name?: string } = {}
+ * ```
+ */
+declare function createFunctionParameter(input: FunctionParameterInput): FunctionParameterNode;
+/**
+ * Creates a {@link FunctionParametersNode} from an ordered list of parameters.
+ *
+ * @example
+ * ```ts
+ * const empty = createFunctionParameters()
+ * // { params: [] }
+ * ```
+ */
+declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
 //#endregion
 //#region src/printers/functionPrinter.d.ts
+/**
+ * Renders a {@link TypeExpression} to its TypeScript source.
+ *
+ * - a `string` is a type reference, returned as-is
+ * - an `IndexedAccessType` becomes `objectType['indexType']`
+ * - a `TypeLiteral` becomes `{ key: Type; key?: Type }`
+ *
+ * `transformType` is applied once to the fully rendered type, matching how the
+ * printer wrapped reference types before the `ts.factory` model.
+ */
+declare function renderType(type: TypeExpression, transformType?: (type: string) => string): string;
 type FunctionPrinterOptions = {
   /**
    * Rendering modes supported by `functionPrinter`.
    *
-   * | Mode          | Output example                              | Use case                        |
-   * |---------------|---------------------------------------------|---------------------------------|
-   * | `declaration` | `id: string, config: Config = {}`           | Function parameter declaration |
-   * | `call`        | `id, { method, url }`                       | Function call arguments |
-   * | `keys`        | `{ id, config }`                            | Key names only (destructuring) |
-   * | `values`      | `{ id: id, config: config }`                | Key/value object entries |
+   * | Mode          | Output example                    | Use case                       |
+   * |---------------|-----------------------------------|--------------------------------|
+   * | `declaration` | `id: string, config: Config = {}` | Function parameter declaration |
+   * | `call`        | `id, { method, url }`             | Function call arguments        |
    */
-  mode: 'declaration' | 'call' | 'keys' | 'values';
+  mode: 'declaration' | 'call';
   /**
    * Optional transformation applied to every parameter name before printing.
    */
@@ -532,8 +747,8 @@ type FunctionPrinterOptions = {
   transformType?: (type: string) => string;
 };
 /**
- * Default function-signature printer.
- * Covers the four standard output modes used across Kubb plugins.
+ * Default function-signature printer. Renders a parameter list in one of two modes:
+ * `declaration` for the function signature and `call` for the call arguments.
  *
  * @example
  * ```ts
@@ -549,32 +764,187 @@ type FunctionPrinterOptions = {
  * printer.print(sig)  // → "petId: string, config: Config = {}"
  * ```
  */
-declare const functionPrinter: (options?: FunctionPrinterOptions | undefined) => {
+declare function functionPrinter(options: FunctionPrinterOptions): {
   name: "functionParameters";
   options: FunctionPrinterOptions;
-  transform: (node: ast.FunctionParamNode) => string | null | undefined;
-  print: (node: ast.FunctionParamNode) => string | null | undefined;
+  print(node: FunctionParametersNode): string;
+};
+//#endregion
+//#region ../../internals/shared/src/operation.d.ts
+/**
+ * Resolver interface for building operation parameters.
+ *
+ * `ResolverTs` from `@kubb/plugin-ts` satisfies this interface and can be passed directly.
+ */
+type OperationParamsResolver = {
+  /**
+   * Naming for an operation's parameters, grouped by location.
+   */
+  param: {
+    /**
+     * Resolves the type name for an individual parameter.
+     *
+     * @example Individual path parameter name
+     * `resolver.param.name(node, param) // → 'DeletePetPathPetId'`
+     */
+    name(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the grouped path parameters type name.
+     * When the return value equals `resolver.param.name`, no indexed access is emitted.
+     *
+     * @example Grouped path params type name
+     * `resolver.param.path(node, param) // → 'DeletePetPath'`
+     */
+    path(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the grouped query parameters type name.
+     * When the return value equals `resolver.param.name`, an inline struct type is emitted instead.
+     *
+     * @example Grouped query params type name
+     * `resolver.param.query(node, param) // → 'FindPetsByStatusQuery'`
+     */
+    query(node: ast.OperationNode, param: ast.ParameterNode): string;
+    /**
+     * Resolves the grouped header parameters type name.
+     * When the return value equals `resolver.param.name`, an inline struct type is emitted instead.
+     *
+     * @example Grouped header params type name
+     * `resolver.param.headers(node, param) // → 'DeletePetHeaders'`
+     */
+    headers(node: ast.OperationNode, param: ast.ParameterNode): string;
+  };
+  /**
+   * Naming for an operation's request and response types.
+   */
+  response: {
+    /**
+     * Resolves the request body type name.
+     *
+     * @example Request body type name
+     * `resolver.response.body(node) // → 'CreatePetBody'`
+     */
+    body(node: ast.OperationNode): string;
+  };
 };
 //#endregion
+//#region src/printers/operationParams.d.ts
+/**
+ * Options for {@link createOperationParams}.
+ */
+type CreateOperationParamsOptions = {
+  /**
+   * How all operation parameters are grouped in the function signature.
+   * - `'object'` wraps all params into a single destructured object `{ petId, data, params }`
+   * - `'inline'` emits each param category as a separate top-level parameter
+   */
+  paramsType: 'object' | 'inline';
+  /**
+   * How path parameters are emitted when `paramsType` is `'inline'`.
+   * - `'object'` groups them as `{ petId, storeId }: PathParams`
+   * - `'inline'` spreads them as individual parameters `petId: string, storeId: string`
+   * - `'inlineSpread'` emits a single rest parameter `...pathParams: PathParams`
+   */
+  pathParamsType: 'object' | 'inline' | 'inlineSpread';
+  /**
+   * Resolver for parameter and request body type names.
+   * Pass `ResolverTs` from `@kubb/plugin-ts` directly.
+   * When omitted, falls back to the schema primitive or `'unknown'`.
+   */
+  resolver?: OperationParamsResolver;
+  /**
+   * Default value for the path parameters binding when `pathParamsType` is `'object'`.
+   * Falls back to `'{}'` when all path params are optional.
+   */
+  pathParamsDefault?: string;
+  /**
+   * Extra parameters appended after the standard operation parameters.
+   *
+   * @example Plugin-specific trailing parameter
+   * ```ts
+   * extraParams: [createFunctionParameter({ name: 'options', type: 'Partial<RequestOptions>', default: '{}' })]
+   * ```
+   */
+  extraParams?: Array<FunctionParameterNode>;
+  /**
+   * Override the default parameter names used for body, query, header, and rest-path groups.
+   *
+   * Useful when targeting languages or frameworks with different naming conventions.
+   *
+   * @default { data: 'data', params: 'params', headers: 'headers', path: 'pathParams' }
+   */
+  paramNames?: {
+    /**
+     * Name for the request body parameter.
+     * @default 'data'
+     */
+    data?: string;
+    /**
+     * Name for the query parameters group parameter.
+     * @default 'params'
+     */
+    params?: string;
+    /**
+     * Name for the header parameters group parameter.
+     * @default 'headers'
+     */
+    headers?: string;
+    /**
+     * Name for the rest path-parameters parameter when `pathParamsType` is `'inlineSpread'`.
+     * @default 'pathParams'
+     */
+    path?: string;
+  };
+  /**
+   * Transforms every resolved type name before it lands in a parameter node, for framework-level
+   * type wrappers.
+   *
+   * @example Vue Query, wrap every parameter type with `MaybeRefOrGetter`
+   * `typeWrapper: (t) => \`MaybeRefOrGetter<${t}>\``
+   */
+  typeWrapper?: (type: string) => string;
+};
+/**
+ * Converts an `OperationNode` into function parameters for code generation.
+ *
+ * Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
+ * destructured object parameter (`object`) and separate top-level parameters (`inline`), while
+ * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
+ * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
+ */
+declare function createOperationParams(node: ast.OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
+//#endregion
 //#region src/resolvers/resolverTs.d.ts
 /**
- * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
- * helpers used by the plugin. Import this in other plugins to resolve the exact names and
- * paths that `plugin-ts` generates without hardcoding the conventions.
+ * Default resolver used by `@kubb/plugin-ts`. Decides the names and file paths
+ * for every generated TypeScript type. Import this in other plugins that need
+ * to reference the exact names `plugin-ts` produces without duplicating the
+ * casing/file-layout rules.
  *
- * The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
- * for identifiers/files and `pascalCase` for type names.
+ * The `default` helpers are supplied by `createResolver`. This plugin overrides the top-level `name`
+ * to use PascalCase for value and type names and `file` to write PascalCase file paths (dotted names
+ * become `/`-joined), and groups the operation-specific naming under the `param`, `response`, and
+ * `enum` namespaces.
  *
- * @example
+ * @example Resolve a type and file name
  * ```ts
- * import { resolver } from '@kubb/plugin-ts'
+ * import { resolverTs } from '@kubb/plugin-ts'
  *
- * resolver.default('list pets', 'type')              // → 'ListPets'
- * resolver.resolveName('list pets status 200')        // → 'ListPetsStatus200'
- * resolver.resolvePathName('list pets', 'file')       // → 'listPets'
+ * resolverTs.name('list pets')                     // 'ListPets'
+ * resolverTs.response.status(node, 200)            // 'ListPetsStatus200'
  * ```
  */
 declare const resolverTs: ResolverTs;
 //#endregion
-export { Enum, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, resolverTs, typeGenerator };
+//#region src/utils.d.ts
+type BuildParamsSchemaOptions = {
+  params: Array<ast.ParameterNode>;
+};
+/**
+ * Builds the object schema for a group of parameters sharing one `in` location (path, query, or
+ * header), embedding each param's own schema (and JSDoc) directly rather than referencing a
+ * separate per-param type — the group itself is the only type these params get exported as.
+ */
+declare function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode;
+//#endregion
+export { type CreateOperationParamsOptions, Enum, type FunctionParameterNode, type FunctionParametersNode, type IndexedAccessTypeNode, type ObjectBindingPatternNode, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, type TypeExpression, type TypeLiteralNode, buildParams, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
 //# sourceMappingURL=index.d.ts.map