@kubb/plugin-ts 5.0.0-alpha.26 → 5.0.0-alpha.28

package/dist/index.d.ts

@@ -1,11 +1,116 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { OperationParamsResolver } from "@kubb/ast";
+import * as _$_kubb_ast0 from "@kubb/ast";
+import { OperationParamsResolver, Printer } from "@kubb/ast";
 import ts from "typescript";
 import * as _$_kubb_core0 from "@kubb/core";
-import { CompatibilityPreset, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, PrinterFactoryOptions, ResolvePathOptions, Resolver, UserGroup } from "@kubb/core";
+import { CompatibilityPreset, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, PrinterFactoryOptions, PrinterPartial, ResolvePathOptions, Resolver, UserGroup } from "@kubb/core";
 import { EnumSchemaNode, FunctionNode, OperationNode, ParameterNode, SchemaNode, StatusCode, Visitor } from "@kubb/ast/types";
 import { FabricReactNode } from "@kubb/react-fabric/types";
 
+//#region src/printers/printerTs.d.ts
+/**
+ * Partial map of node-type overrides for the TypeScript printer.
+ *
+ * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function
+ * replaces the built-in handler for that node type. Use `this.transform` to
+ * recurse into nested schema nodes, and `this.options` to read printer options.
+ *
+ * @example Override the `date` handler
+ * ```ts
+ * pluginTs({
+ *   printer: {
+ *     nodes: {
+ *       date(node) {
+ *         return ts.factory.createTypeReferenceNode('Date', [])
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+type PrinterTsNodes = PrinterPartial<ts.TypeNode, PrinterTsOptions>;
+type PrinterTsOptions = {
+  /**
+   * @default `'questionToken'`
+   */
+  optionalType: PluginTs['resolvedOptions']['optionalType'];
+  /**
+   * @default `'array'`
+   */
+  arrayType: PluginTs['resolvedOptions']['arrayType'];
+  /**
+   * @default `'inlineLiteral'`
+   */
+  enumType: PluginTs['resolvedOptions']['enumType'];
+  /**
+   * Suffix appended to the generated type alias name when `enumType` is `asConst` or `asPascalConst`.
+   *
+   * @default `'Key'`
+   */
+  enumTypeSuffix?: PluginTs['resolvedOptions']['enumTypeSuffix'];
+  /**
+   * Controls whether a `type` alias or `interface` declaration is emitted.
+   * @default `'type'`
+   */
+  syntaxType?: PluginTs['resolvedOptions']['syntaxType'];
+  /**
+   * When set, `printer.print(node)` produces a full `type Name = …` declaration.
+   * When omitted, `printer.print(node)` returns the raw type node.
+   */
+  name?: string;
+  /**
+   * JSDoc `@description` comment added to the generated type or interface declaration.
+   */
+  description?: string;
+  /**
+   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+   * Forces type-alias syntax even when `syntaxType` is `'interface'`.
+   */
+  keysToOmit?: Array<string>;
+  /**
+   * Resolver used to transform raw schema names into valid TypeScript identifiers.
+   */
+  resolver: ResolverTs;
+  /**
+   * Names of top-level schemas that are enums.
+   * When set, the `ref` handler uses the suffixed type name (e.g. `StatusKey`) for enum refs
+   * instead of the plain PascalCase name, so imports align with what the enum file actually exports.
+   */
+  enumSchemaNames?: Set<string>;
+  /**
+   * Partial map of node-type overrides. Each entry replaces the built-in handler for that node type.
+   */
+  nodes?: PrinterTsNodes;
+};
+/**
+ * TypeScript printer factory options: maps `SchemaNode` → `ts.TypeNode` (raw) or `ts.Node` (full declaration).
+ */
+type PrinterTsFactory = PrinterFactoryOptions<'typescript', PrinterTsOptions, ts.TypeNode, string>;
+/**
+ * TypeScript type printer built with `definePrinter`.
+ *
+ * Converts a `SchemaNode` AST node into a TypeScript AST node:
+ * - **`printer.print(node)`** — when `options.typeName` is set, returns a full
+ *   `type Name = …` or `interface Name { … }` declaration (`ts.Node`).
+ *   Without `typeName`, returns the raw `ts.TypeNode` for the schema.
+ *
+ * Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
+ * over per printer instance, so each call to `printerTs(options)` produces an independent printer.
+ *
+ * @example Raw type node (no `typeName`)
+ * ```ts
+ * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: '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 declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
+ * ```
+ */
+declare const printerTs: (options?: PrinterTsOptions | undefined) => _$_kubb_ast0.Printer<PrinterTsFactory>;
+//#endregion
 //#region src/types.d.ts
 /**
  * The concrete resolver type for `@kubb/plugin-ts`.
@@ -20,7 +125,7 @@ type ResolverTs = Resolver & OperationParamsResolver & {
    * @example
    * resolver.resolveName('list pets status 200') // → 'ListPetsStatus200'
    */
-  resolveName(name: string): string;
+  resolveTypeName(name: string): string;
   /**
    * Resolves the file/path name for a given identifier using PascalCase.
    *
@@ -244,35 +349,47 @@ type Options = {
    */
   compatibilityPreset?: CompatibilityPreset;
   /**
-   * Array of named resolvers that control naming conventions.
-   * Later entries override earlier ones (last wins).
-   * Built-in: `resolverTs` (default), `resolverTsLegacy`.
-   * @default [resolverTs]
+   * Override naming conventions. When a method returns `null` or `undefined`, the preset
+   * resolver (`resolverTs` / `resolverTsLegacy`) is used as fallback.
    */
-  resolvers?: Array<ResolverTs>;
+  resolver?: Partial<ResolverTs> & ThisType<ResolverTs>;
   /**
-   * Array of AST visitors applied to each SchemaNode/OperationNode before printing.
-   * Uses `transform()` from `@kubb/ast` — visitors can modify, replace, or annotate nodes.
+   * AST visitor applied to each schema/operation node before printing.
+   * Returning `null` or `undefined` from a visitor method falls back to the preset transformer.
    *
    * @example Remove writeOnly properties from response types
    * ```ts
-   * transformers: [{
+   * transformer: {
    *   property(node) {
    *     if (node.schema.writeOnly) return undefined
    *   }
-   * }]
+   * }
    * ```
+   */
+  transformer?: Visitor;
+  /**
+   * Override individual printer node handlers to customise 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.
    *
-   * @example Force all dates to plain strings
+   * @example Override the `date` node to use the `Date` object type
    * ```ts
-   * transformers: [{
-   *   schema(node) {
-   *     if (node.type === 'date') return { ...node, type: 'string' }
-   *   }
-   * }]
+   * import ts from 'typescript'
+   * pluginTs({
+   *   printer: {
+   *     nodes: {
+   *       date(node) {
+   *         return ts.factory.createTypeReferenceNode('Date', [])
+   *       },
+   *     },
+   *   },
+   * })
    * ```
    */
-  transformers?: Array<Visitor>;
+  printer?: {
+    nodes?: PrinterTsNodes;
+  };
 } & EnumTypeOptions;
 type ResolvedOptions = {
   output: Output;
@@ -284,7 +401,7 @@ type ResolvedOptions = {
   arrayType: NonNullable<Options['arrayType']>;
   syntaxType: NonNullable<Options['syntaxType']>;
   paramsCasing: Options['paramsCasing'];
-  transformers: Array<Visitor>;
+  printer: Options['printer'];
 };
 type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>;
 //#endregion
@@ -326,35 +443,24 @@ declare function Enum({
 type Props = {
   name: string;
   node: SchemaNode;
-  optionalType: PluginTs['resolvedOptions']['optionalType'];
-  arrayType: PluginTs['resolvedOptions']['arrayType'];
+  /**
+   * Pre-configured printer instance created by the generator.
+   * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.
+   */
+  printer: Printer<PrinterTsFactory>;
   enumType: PluginTs['resolvedOptions']['enumType'];
   enumTypeSuffix: PluginTs['resolvedOptions']['enumTypeSuffix'];
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing'];
-  syntaxType: PluginTs['resolvedOptions']['syntaxType'];
   resolver: PluginTs['resolver'];
-  description?: string;
-  keysToOmit?: string[];
-  /**
-   * Names of top-level schemas that are enums.
-   * Used so the printer's `ref` handler can use the suffixed type name (e.g. `StatusKey`)
-   * instead of the plain PascalCase name (e.g. `Status`) when resolving `$ref` enum targets.
-   */
-  enumSchemaNames?: Set<string>;
 };
 declare function Type({
   name,
   node,
-  keysToOmit,
-  optionalType,
-  arrayType,
-  syntaxType,
+  printer,
   enumType,
   enumTypeSuffix,
   enumKeyCasing,
-  description,
-  resolver,
-  enumSchemaNames
+  resolver
 }: Props): FabricReactNode;
 //#endregion
 //#region src/generators/typeGenerator.d.ts
@@ -430,85 +536,6 @@ declare const functionPrinter: (options?: FunctionPrinterOptions | undefined) =>
   print: (node: FunctionNode) => string | null | undefined;
 };
 //#endregion
-//#region src/printers/printerTs.d.ts
-type TsOptions = {
-  /**
-   * @default `'questionToken'`
-   */
-  optionalType: PluginTs['resolvedOptions']['optionalType'];
-  /**
-   * @default `'array'`
-   */
-  arrayType: PluginTs['resolvedOptions']['arrayType'];
-  /**
-   * @default `'inlineLiteral'`
-   */
-  enumType: PluginTs['resolvedOptions']['enumType'];
-  /**
-   * Suffix appended to the generated type alias name when `enumType` is `asConst` or `asPascalConst`.
-   *
-   * @default `'Key'`
-   */
-  enumTypeSuffix?: PluginTs['resolvedOptions']['enumTypeSuffix'];
-  /**
-   * Controls whether a `type` alias or `interface` declaration is emitted.
-   * @default `'type'`
-   */
-  syntaxType?: PluginTs['resolvedOptions']['syntaxType'];
-  /**
-   * When set, `printer.print(node)` produces a full `type Name = …` declaration.
-   * When omitted, `printer.print(node)` returns the raw type node.
-   */
-  name?: string;
-  /**
-   * JSDoc `@description` comment added to the generated type or interface declaration.
-   */
-  description?: string;
-  /**
-   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
-   * Forces type-alias syntax even when `syntaxType` is `'interface'`.
-   */
-  keysToOmit?: Array<string>;
-  /**
-   * Resolver used to transform raw schema names into valid TypeScript identifiers.
-   */
-  resolver: ResolverTs;
-  /**
-   * Names of top-level schemas that are enums.
-   * When set, the `ref` handler uses the suffixed type name (e.g. `StatusKey`) for enum refs
-   * instead of the plain PascalCase name, so imports align with what the enum file actually exports.
-   */
-  enumSchemaNames?: Set<string>;
-};
-/**
- * TypeScript printer factory options: maps `SchemaNode` → `ts.TypeNode` (raw) or `ts.Node` (full declaration).
- */
-type TsPrinter = PrinterFactoryOptions<'typescript', TsOptions, ts.TypeNode, string>;
-/**
- * TypeScript type printer built with `definePrinter`.
- *
- * Converts a `SchemaNode` AST node into a TypeScript AST node:
- * - **`printer.print(node)`** — when `options.typeName` is set, returns a full
- *   `type Name = …` or `interface Name { … }` declaration (`ts.Node`).
- *   Without `typeName`, returns the raw `ts.TypeNode` for the schema.
- *
- * Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
- * over per printer instance, so each call to `printerTs(options)` produces an independent printer.
- *
- * @example Raw type node (no `typeName`)
- * ```ts
- * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: '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 declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
- * ```
- */
-declare const printerTs: (options?: TsOptions | undefined) => _$_kubb_core0.Printer<TsPrinter>;
-//#endregion
 //#region src/resolvers/resolverTs.d.ts
 /**
  * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
@@ -555,5 +582,5 @@ declare const resolverTs: ResolverTs;
  */
 declare const resolverTsLegacy: ResolverTs;
 //#endregion
-export { Enum, type PluginTs, type ResolverTs, Type, functionPrinter, pluginTs, pluginTsName, printerTs, resolverTs, resolverTsLegacy, typeGenerator };
+export { Enum, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, functionPrinter, pluginTs, pluginTsName, printerTs, resolverTs, resolverTsLegacy, typeGenerator };
 //# sourceMappingURL=index.d.ts.map