@kubb/plugin-ts 5.0.0-beta.15 → 5.0.0-beta.25

package/dist/index.d.ts

@@ -82,7 +82,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.
    */
@@ -238,7 +238,7 @@ type EnumTypeOptions = {
   /**
    * Suffix appended to the generated type alias name.
    *
-   * Only affects the type alias — the const object name is unchanged.
+   * Only affects the type alias; the const object name is unchanged.
    *
    * @default 'Key'
    * @example enumTypeSuffix: 'Value' → `export type PetStatusValue = …`
@@ -293,80 +293,88 @@ type EnumTypeOptions = {
   enumTypeSuffix?: never;
   /**
    * `enumKeyCasing` has no effect for this `enumType`.
-   * Literal and inlineLiteral modes emit only values — keys are discarded entirely.
+   * Literal and inlineLiteral modes emit only values; keys are discarded entirely.
    */
   enumKeyCasing?: never;
 };
 type Options = {
   /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'types', barrelType: 'named' }
+   * Where the generated `.ts` files are written and how they are exported.
+   *
+   * @default { path: 'types', barrel: { type: 'named' } }
    */
   output?: Output;
   /**
-   * Define which contentType should be used.
-   * By default, uses the first valid JSON media type.
+   * Media type read from the OpenAPI spec when an operation defines several.
+   * Defaults to the first JSON-compatible media type Kubb finds.
    */
   contentType?: 'application/json' | (string & {});
   /**
-   * Group the clients based on the provided name.
+   * Split generated files into subfolders based on the operation's tag.
    */
   group?: Group;
   /**
-   * 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
+   * Rename properties inside `PathParams`, `QueryParams`, and `HeaderParams` types.
+   * Response and request body types are not affected.
+   *
+   * @note Every plugin that touches operation parameters must use the same value.
    */
   paramsCasing?: 'camelcase';
   /**
-   * Define some generators next to the ts generators
+   * Custom generators that run alongside the built-in TypeScript 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, 'function')` delegates to the built-in
+   * implementation.
    */
   resolver?: Partial<ResolverTs> & ThisType<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.
+   * AST visitor applied to each schema or operation node before printing.
+   * Methods you omit fall back to the preset transformer.
    *
-   * @example Remove writeOnly properties from response types
+   * @example Drop writeOnly properties from response types
    * ```ts
    * transformer: {
    *   property(node) {
@@ -377,18 +385,17 @@ type Options = {
    */
   transformer?: ast.Visitor;
   /**
-   * 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', [])
    *       },
    *     },
@@ -405,7 +412,7 @@ type ResolvedOptions = {
   exclude: Array<Exclude>;
   include: Array<Include> | undefined;
   override: Array<Override<ResolvedOptions>>;
-  group: Group | undefined;
+  group: Group | null;
   enumType: NonNullable<Options['enumType']>;
   enumTypeSuffix: NonNullable<Options['enumTypeSuffix']>;
   enumKeyCasing: EnumKeyCasing;
@@ -484,26 +491,41 @@ declare function Type({
 }: Props): KubbReactNode;
 //#endregion
 //#region src/generators/typeGenerator.d.ts
+/**
+ * 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: _$_kubb_core0.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'
+ * import { pluginTs } from '@kubb/plugin-ts'
  *
  * export default defineConfig({
- *   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs({
+ *       output: { path: './types' },
+ *       enumType: 'asConst',
+ *       optionalType: 'questionTokenAndUndefined',
+ *     }),
+ *   ],
  * })
  * ```
  */
@@ -552,26 +574,27 @@ type FunctionPrinterOptions = {
 declare const functionPrinter: (options?: FunctionPrinterOptions | undefined) => {
   name: "functionParameters";
   options: FunctionPrinterOptions;
-  transform: (node: ast.FunctionParamNode) => string | null | undefined;
-  print: (node: ast.FunctionParamNode) => string | null | undefined;
+  transform: (node: ast.FunctionParamNode) => string | null;
+  print: (node: ast.FunctionParamNode) => string | null;
 };
 //#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` method is supplied by `defineResolver`. It uses PascalCase for
+ * type names and PascalCase-with-isFile for files.
  *
- * @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.default('list pets', 'type')        // 'ListPets'
+ * resolverTs.resolvePathName('list pets', 'file') // 'ListPets'
+ * resolverTs.resolveResponseStatusName(node, 200) // 'ListPetsStatus200'
  * ```
  */
 declare const resolverTs: ResolverTs;

package/dist/index.js

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { safePrint } from "@kubb/parser-ts";
+import { parserTs } from "@kubb/parser-ts";
 import { File, jsxRendererSync } from "@kubb/renderer-jsx";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
 import { isNumber } from "remeda";
@@ -634,13 +634,13 @@ function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
 		isExportable: true,
 		isIndexable: true,
 		isTypeOnly: false,
-		children: safePrint(nameNode)
+		children: parserTs.print(nameNode)
 	}), /* @__PURE__ */ jsx(File.Source, {
 		name: typeName,
 		isIndexable: true,
 		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
 		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
-		children: safePrint(typeNode)
+		children: parserTs.print(typeNode)
 	})] });
 }
 //#endregion
@@ -703,14 +703,14 @@ function buildPropertyJSDocComments(schema) {
 	const meta = ast.syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
 	return [
-		meta && "description" in meta && meta.description ? `@description ${jsStringEscape(meta.description)}` : void 0,
-		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : void 0,
-		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : void 0,
-		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : void 0,
-		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : void 0,
-		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? stringify(meta.default) : meta.default}` : void 0,
-		meta && "example" in meta && meta.example !== void 0 ? `@example ${meta.example}` : void 0,
-		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+		meta && "description" in meta && meta.description ? `@description ${jsStringEscape(meta.description)}` : null,
+		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
+		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
+		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
+		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? stringify(meta.default) : meta.default}` : null,
+		meta && "example" in meta && meta.example !== void 0 ? `@example ${meta.example}` : null,
+		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, "optional" in schema && schema.optional ? " | undefined" : null].filter(Boolean).join("") : null
 	].filter(Boolean);
 }
 function buildParams(node, { params, resolver }) {
@@ -876,7 +876,7 @@ const printerTs = ast.definePrinter((options) => {
 			date: dateOrStringNode,
 			time: dateOrStringNode,
 			ref(node) {
-				if (!node.name) return;
+				if (!node.name) return null;
 				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
 				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
 			},
@@ -913,16 +913,16 @@ const printerTs = ast.definePrinter((options) => {
 				return createIntersectionDeclaration({
 					withParentheses: true,
 					nodes: buildMemberNodes(node.members, this.transform)
-				}) ?? void 0;
+				}) ?? null;
 			},
 			array(node) {
 				return createArrayDeclaration({
 					nodes: (node.items ?? []).map((item) => this.transform(item)).filter(isNonNullable),
 					arrayType: this.options.arrayType
-				}) ?? void 0;
+				}) ?? null;
 			},
 			tuple(node) {
-				return buildTupleNode(node, this.transform);
+				return buildTupleNode(node, this.transform) ?? null;
 			},
 			object(node) {
 				const { transform, options } = this;
@@ -949,32 +949,34 @@ const printerTs = ast.definePrinter((options) => {
 		},
 		print(node) {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) return null;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
 			const meta = ast.syncSchemaRef(node);
 			if (!name) {
-				if (meta.nullable) base = createUnionDeclaration({ nodes: [base, keywordTypeNodes.null] });
-				if ((meta.nullish || meta.optional) && addsUndefined) base = createUnionDeclaration({ nodes: [base, keywordTypeNodes.undefined] });
-				return safePrint(base);
+				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [transformed, keywordTypeNodes.null] }) : transformed;
+				const result = (meta.nullish || meta.optional) && addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
+				return parserTs.print(result);
 			}
-			let inner = keysToOmit?.length ? createOmitDeclaration({
-				keys: keysToOmit,
-				type: base,
-				nonNullable: true
-			}) : base;
-			if (meta.nullable) inner = createUnionDeclaration({ nodes: [inner, keywordTypeNodes.null] });
-			if (meta.nullish || meta.optional) inner = createUnionDeclaration({ nodes: [inner, keywordTypeNodes.undefined] });
-			const useTypeGeneration = syntaxType === "type" || inner.kind === syntaxKind.union || !!keysToOmit?.length;
-			return safePrint(createTypeDeclaration({
+			const inner = (() => {
+				const omitted = keysToOmit?.length ? createOmitDeclaration({
+					keys: keysToOmit,
+					type: transformed,
+					nonNullable: true
+				}) : transformed;
+				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [omitted, keywordTypeNodes.null] }) : omitted;
+				return meta.nullish || meta.optional ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
+			})();
+			const typeNode = createTypeDeclaration({
 				name,
 				isExportable: true,
 				type: inner,
-				syntax: useTypeGeneration ? "type" : "interface",
+				syntax: syntaxType === "type" || inner.kind === syntaxKind.union || !!keysToOmit?.length ? "type" : "interface",
 				comments: buildPropertyJSDocComments({
 					...meta,
 					description
 				})
-			}));
+			});
+			return parserTs.print(typeNode);
 		}
 	};
 });
@@ -993,15 +995,21 @@ function getPerContentTypeName(dataName, suffix) {
 	if (dataName.endsWith("Data")) return suffix.endsWith("Data") ? dataName.slice(0, -4) + suffix : `${dataName.slice(0, -4)}${suffix}Data`;
 	return dataName + suffix;
 }
+/**
+* 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.
+*/
 const typeGenerator = defineGenerator({
 	name: "typescript",
 	renderer: jsxRendererSync,
 	schema(node, ctx) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
-		const { adapter, config, resolver, root, inputNode } = ctx;
+		const { adapter, config, resolver, root } = ctx;
 		if (!node.name) return;
 		const mode = ctx.getMode(output);
-		const enumSchemaNames = new Set(inputNode.schemas.filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name));
+		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
 			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
 			return resolver.resolveTypeName(schemaName);
@@ -1014,7 +1022,7 @@ const typeGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}).path
 		}));
 		const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum);
@@ -1026,7 +1034,7 @@ const typeGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			})
 		};
 		const schemaPrinter = printerTs({
@@ -1045,11 +1053,11 @@ const typeGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
 				config
 			}),
-			footer: resolver.resolveFooter(inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
 				config
 			}),
@@ -1075,7 +1083,7 @@ const typeGenerator = defineGenerator({
 	},
 	operation(node, ctx) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
-		const { adapter, config, resolver, root, inputNode } = ctx;
+		const { adapter, config, resolver, root } = ctx;
 		const mode = ctx.getMode(output);
 		const params = ast.caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
@@ -1086,9 +1094,9 @@ const typeGenerator = defineGenerator({
 		}, {
 			root,
 			output,
-			group
+			group: group ?? void 0
 		}) };
-		const enumSchemaNames = new Set(inputNode.schemas.filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name));
+		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
 			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
 			return resolver.resolveTypeName(schemaName);
@@ -1103,7 +1111,7 @@ const typeGenerator = defineGenerator({
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				}).path
 			}));
 			const schemaPrinter = printerTs({
@@ -1227,11 +1235,11 @@ const typeGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
 				config
 			}),
-			footer: resolver.resolveFooter(inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
 				config
 			}),
@@ -1249,20 +1257,21 @@ const typeGenerator = defineGenerator({
 //#endregion
 //#region src/resolvers/resolverTs.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` method is supplied by `defineResolver`. It uses PascalCase for
+* type names and PascalCase-with-isFile for files.
 *
-* @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.default('list pets', 'type')        // 'ListPets'
+* resolverTs.resolvePathName('list pets', 'file') // 'ListPets'
+* resolverTs.resolveResponseStatusName(node, 200) // 'ListPetsStatus200'
 * ```
 */
 const resolverTs = defineResolver(() => {
@@ -1313,22 +1322,31 @@ const resolverTs = defineResolver(() => {
 //#endregion
 //#region src/plugin.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.
 */
 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'
+* import { pluginTs } from '@kubb/plugin-ts'
 *
 * export default defineConfig({
-*   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs({
+*       output: { path: './types' },
+*       enumType: 'asConst',
+*       optionalType: 'questionTokenAndUndefined',
+*     }),
+*   ],
 * })
 * ```
 */
@@ -1343,7 +1361,7 @@ const pluginTs = definePlugin((options) => {
 			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
 			return `${camelCase(ctx.group)}Controller`;
 		}
-	} : void 0;
+	} : null;
 	return {
 		name: pluginTsName,
 		options,