@kubb/plugin-ts 5.0.0-alpha.21 → 5.0.0-alpha.23

package/dist/resolverTsLegacy-sJ16Iqrl.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolverTsLegacy-sJ16Iqrl.cjs","names":["pascalCase"],"sources":["../src/resolvers/resolverTs.ts","../src/resolvers/resolverTsLegacy.ts"],"sourcesContent":["import { pascalCase } from '@internals/utils'\nimport { defineResolver } from '@kubb/core'\nimport type { PluginTs } from '../types.ts'\n\nfunction resolveName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string {\n  return pascalCase(name, { isFile: type === 'file' })\n}\n\n/**\n * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution\n * helpers used by the plugin. Import this in other plugins to resolve the exact names and\n * paths that `plugin-ts` generates without hardcoding the conventions.\n *\n * The `default` method is automatically injected by `defineResolver` — it uses `camelCase`\n * for identifiers/files and `pascalCase` for type names.\n *\n * @example\n * ```ts\n * import { resolver } from '@kubb/plugin-ts'\n *\n * resolver.default('list pets', 'type')              // → 'ListPets'\n * resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'\n * resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'\n * resolver.resolvePathName('list pets', 'file')       // → 'listPets'\n * ```\n */\nexport const resolverTs = defineResolver<PluginTs>(() => {\n  return {\n    name: 'default',\n    pluginName: 'plugin-ts',\n    default(name, type) {\n      return resolveName(name, type)\n    },\n    resolveName(name) {\n      return this.default(name, 'function')\n    },\n    resolveTypedName(name) {\n      return this.default(name, 'type')\n    },\n    resolvePathName(name, type) {\n      return this.default(name, type)\n    },\n    resolveParamName(node, param) {\n      return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`)\n    },\n    resolveParamTypedName(node, param) {\n      return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`)\n    },\n    resolveResponseStatusName(node, statusCode) {\n      return this.resolveName(`${node.operationId} Status ${statusCode}`)\n    },\n    resolveResponseStatusTypedName(node, statusCode) {\n      return this.resolveTypedName(`${node.operationId} Status ${statusCode}`)\n    },\n    resolveDataName(node) {\n      return this.resolveName(`${node.operationId} Data`)\n    },\n    resolveDataTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} Data`)\n    },\n    resolveRequestConfigName(node) {\n      return this.resolveName(`${node.operationId} RequestConfig`)\n    },\n    resolveRequestConfigTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} RequestConfig`)\n    },\n    resolveResponsesName(node) {\n      return this.resolveName(`${node.operationId} Responses`)\n    },\n    resolveResponsesTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} Responses`)\n    },\n    resolveResponseName(node) {\n      return this.resolveName(`${node.operationId} Response`)\n    },\n    resolveResponseTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} Response`)\n    },\n    resolveEnumKeyTypedName(node) {\n      return `${this.resolveTypedName(node.name ?? '')}Key`\n    },\n    resolvePathParamsName(_node) {\n      throw new Error(\"resolvePathParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.\")\n    },\n    resolvePathParamsTypedName(_node) {\n      throw new Error(\n        \"resolvePathParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.\",\n      )\n    },\n    resolveQueryParamsName(_node) {\n      throw new Error(\"resolveQueryParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.\")\n    },\n    resolveQueryParamsTypedName(_node) {\n      throw new Error(\n        \"resolveQueryParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.\",\n      )\n    },\n    resolveHeaderParamsName(_node) {\n      throw new Error(\"resolveHeaderParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.\")\n    },\n    resolveHeaderParamsTypedName(_node) {\n      throw new Error(\n        \"resolveHeaderParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.\",\n      )\n    },\n  }\n})\n","import { defineResolver } from '@kubb/core'\nimport type { PluginTs } from '../types.ts'\nimport { resolverTs } from './resolverTs.ts'\n\n/**\n * Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions\n * used before the v2 resolver refactor. Enable via `compatibilityPreset: 'kubbV4'`\n * (or by composing this resolver manually).\n *\n * Key differences from the default resolver:\n * - Response status types: `<OperationId><StatusCode>` (e.g. `CreatePets201`) instead of `<OperationId>Status201`\n * - Default/error responses: `<OperationId>Error` instead of `<OperationId>StatusDefault`\n * - Request body: `<OperationId>MutationRequest` (non-GET) / `<OperationId>QueryRequest` (GET)\n * - Combined responses type: `<OperationId>Mutation` / `<OperationId>Query`\n * - Response union: `<OperationId>MutationResponse` / `<OperationId>QueryResponse`\n *\n * @example\n * ```ts\n * import { resolverTsLegacy } from '@kubb/plugin-ts'\n *\n * resolverTsLegacy.resolveResponseStatusTypedName(node, 201)  // → 'CreatePets201'\n * resolverTsLegacy.resolveResponseStatusTypedName(node, 'default')  // → 'CreatePetsError'\n * resolverTsLegacy.resolveDataTypedName(node)  // → 'CreatePetsMutationRequest' (POST)\n * resolverTsLegacy.resolveResponsesTypedName(node)  // → 'CreatePetsMutation' (POST)\n * resolverTsLegacy.resolveResponseTypedName(node)  // → 'CreatePetsMutationResponse' (POST)\n * ```\n */\nexport const resolverTsLegacy = defineResolver<PluginTs>(() => {\n  return {\n    ...resolverTs,\n    pluginName: 'plugin-ts',\n    resolveResponseStatusName(node, statusCode) {\n      if (statusCode === 'default') {\n        return this.resolveName(`${node.operationId} Error`)\n      }\n      return this.resolveName(`${node.operationId} ${statusCode}`)\n    },\n    resolveResponseStatusTypedName(node, statusCode) {\n      if (statusCode === 'default') {\n        return this.resolveTypedName(`${node.operationId} Error`)\n      }\n      return this.resolveTypedName(`${node.operationId} ${statusCode}`)\n    },\n    resolveDataName(node) {\n      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'\n      return this.resolveName(`${node.operationId} ${suffix}`)\n    },\n    resolveDataTypedName(node) {\n      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'\n      return this.resolveTypedName(`${node.operationId} ${suffix}`)\n    },\n    resolveResponsesName(node) {\n      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'\n      return `${this.default(node.operationId, 'function')}${suffix}`\n    },\n    resolveResponsesTypedName(node) {\n      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'\n      return `${this.default(node.operationId, 'type')}${suffix}`\n    },\n    resolveResponseName(node) {\n      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'\n      return this.resolveName(`${node.operationId} ${suffix}`)\n    },\n    resolveResponseTypedName(node) {\n      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'\n      return this.resolveTypedName(`${node.operationId} ${suffix}`)\n    },\n    resolvePathParamsName(node) {\n      return this.resolveName(`${node.operationId} PathParams`)\n    },\n    resolvePathParamsTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} PathParams`)\n    },\n    resolveQueryParamsName(node) {\n      return this.resolveName(`${node.operationId} QueryParams`)\n    },\n    resolveQueryParamsTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} QueryParams`)\n    },\n    resolveHeaderParamsName(node) {\n      return this.resolveName(`${node.operationId} HeaderParams`)\n    },\n    resolveHeaderParamsTypedName(node) {\n      return this.resolveTypedName(`${node.operationId} HeaderParams`)\n    },\n  }\n})\n"],"mappings":"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"}

package/dist/resolvers.cjs

@@ -1,4 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_resolverTsLegacy = require("./resolverTsLegacy-sJ16Iqrl.cjs");
-exports.resolverTs = require_resolverTsLegacy.resolverTs;
-exports.resolverTsLegacy = require_resolverTsLegacy.resolverTsLegacy;

package/dist/resolvers.d.ts

@@ -1,52 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { i as ResolverTs } from "./types-BcyuFDn9.js";
-
-//#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.
- *
- * The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
- * for identifiers/files and `pascalCase` for type names.
- *
- * @example
- * ```ts
- * import { resolver } from '@kubb/plugin-ts'
- *
- * resolver.default('list pets', 'type')              // → 'ListPets'
- * resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
- * resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
- * resolver.resolvePathName('list pets', 'file')       // → 'listPets'
- * ```
- */
-declare const resolverTs: ResolverTs;
-//#endregion
-//#region src/resolvers/resolverTsLegacy.d.ts
-/**
- * Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions
- * used before the v2 resolver refactor. Enable via `compatibilityPreset: 'kubbV4'`
- * (or by composing this resolver manually).
- *
- * Key differences from the default resolver:
- * - Response status types: `<OperationId><StatusCode>` (e.g. `CreatePets201`) instead of `<OperationId>Status201`
- * - Default/error responses: `<OperationId>Error` instead of `<OperationId>StatusDefault`
- * - Request body: `<OperationId>MutationRequest` (non-GET) / `<OperationId>QueryRequest` (GET)
- * - Combined responses type: `<OperationId>Mutation` / `<OperationId>Query`
- * - Response union: `<OperationId>MutationResponse` / `<OperationId>QueryResponse`
- *
- * @example
- * ```ts
- * import { resolverTsLegacy } from '@kubb/plugin-ts'
- *
- * resolverTsLegacy.resolveResponseStatusTypedName(node, 201)  // → 'CreatePets201'
- * resolverTsLegacy.resolveResponseStatusTypedName(node, 'default')  // → 'CreatePetsError'
- * resolverTsLegacy.resolveDataTypedName(node)  // → 'CreatePetsMutationRequest' (POST)
- * resolverTsLegacy.resolveResponsesTypedName(node)  // → 'CreatePetsMutation' (POST)
- * resolverTsLegacy.resolveResponseTypedName(node)  // → 'CreatePetsMutationResponse' (POST)
- * ```
- */
-declare const resolverTsLegacy: ResolverTs;
-//#endregion
-export { resolverTs, resolverTsLegacy };
-//# sourceMappingURL=resolvers.d.ts.map

package/dist/resolvers.js

@@ -1,2 +0,0 @@
-import { n as resolverTs, t as resolverTsLegacy } from "./resolverTsLegacy-DLl854-P.js";
-export { resolverTs, resolverTsLegacy };

package/dist/types-BcyuFDn9.d.ts

@@ -1,344 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { Builder, CompatibilityPreset, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, ResolvePathOptions, Resolver } from "@kubb/core";
-import { OperationNode, ParameterNode, SchemaNode, StatusCode, Visitor } from "@kubb/ast/types";
-
-//#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.
- */
-type ResolverTs = Resolver & {
-  /**
-   * Resolves the variable/function name for a given raw name (equivalent to `default(name, 'function')`).
-   * Use this shorthand when matching the `name` field produced by the v2 TypeGenerator,
-   * so call-sites don't need to repeat the `'function'` type literal.
-   *
-   * @example
-   * resolver.resolveName('list pets status 200') // → 'listPetsStatus200'
-   */
-  resolveName(name: string): string;
-  /**
-   * Resolves the TypeScript type name for a given raw name (equivalent to `default(name, 'type')`).
-   * Use this shorthand when matching the `typedName` field produced by the v2 TypeGenerator,
-   * so call-sites don't need to repeat the `'type'` type literal.
-   *
-   * @example
-   * resolver.resolveTypedName('list pets status 200') // → 'ListPetsStatus200'
-   */
-  resolveTypedName(name: string): string;
-  /**
-   * Resolves the file/path name for a given identifier using PascalCase.
-   *
-   * @example
-   * resolver.resolvePathName('list pets', 'file') // → 'ListPets'
-   */
-  resolvePathName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  /**
-   * Resolves the variable/function name for an operation parameter.
-   * Encapsulates the `<operationId> <PascalCase(paramIn)> <paramName>` naming convention.
-   *
-   * @example
-   * resolver.resolveParamName(node, param) // → 'ListPetsQueryLimit'
-   */
-  resolveParamName(node: OperationNode, param: ParameterNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an operation parameter
-   * (equivalent to `resolveParamName` with `type: 'type'`).
-   * In the default implementation both return the same PascalCase string;
-   * the distinction is preserved so overrides can diverge the two forms.
-   *
-   * @example
-   * resolver.resolveParamTypedName(node, param) // → 'ListPetsQueryLimit'
-   */
-  resolveParamTypedName(node: OperationNode, param: ParameterNode): string;
-  /**
-   * Resolves the variable/function name for an operation response by status code.
-   * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
-   *
-   * @example
-   * resolver.resolveResponseStatusName(node, 200) // → 'ListPetsStatus200'
-   */
-  resolveResponseStatusName(node: OperationNode, statusCode: StatusCode): string;
-  /**
-   * Resolves the TypeScript type alias name for an operation response by status code.
-   * Encapsulates the `<operationId> Status <statusCode>` template with PascalCase applied to the result.
-   *
-   * @example
-   * resolver.resolveResponseStatusTypedName(node, 200) // → 'ListPetsStatus200'
-   */
-  resolveResponseStatusTypedName(node: OperationNode, statusCode: StatusCode): string;
-  /**
-   * Resolves the variable/function name for an operation's request body (`Data`).
-   *
-   * @example
-   * resolver.resolveDataName(node) // → 'ListPetsData'
-   */
-  resolveDataName(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an operation's request body (`Data`).
-   *
-   * @example
-   * resolver.resolveDataTypedName(node) // → 'ListPetsData'
-   */
-  resolveDataTypedName(node: OperationNode): string;
-  /**
-   * Resolves the variable/function name for an operation's request config (`RequestConfig`).
-   *
-   * @example
-   * resolver.resolveRequestConfigName(node) // → 'ListPetsRequestConfig'
-   */
-  resolveRequestConfigName(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an operation's request config (`RequestConfig`).
-   *
-   * @example
-   * resolver.resolveRequestConfigTypedName(node) // → 'ListPetsRequestConfig'
-   */
-  resolveRequestConfigTypedName(node: OperationNode): string;
-  /**
-   * Resolves the variable/function name for the collection of all operation responses (`Responses`).
-   *
-   * @example
-   * resolver.resolveResponsesName(node) // → 'ListPetsResponses'
-   */
-  resolveResponsesName(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for the collection of all operation responses.
-   *
-   * @example
-   * resolver.resolveResponsesTypedName(node) // → 'ListPetsResponses'
-   */
-  resolveResponsesTypedName(node: OperationNode): string;
-  /**
-   * Resolves the variable/function name for the union of all operation responses (`Response`).
-   *
-   * @example
-   * resolver.resolveResponseName(node) // → 'ListPetsResponse'
-   */
-  resolveResponseName(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for the union of all operation responses.
-   *
-   * @example
-   * resolver.resolveResponseTypedName(node) // → 'ListPetsResponse'
-   */
-  resolveResponseTypedName(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an enum schema's key variant.
-   * Appends the `Key` suffix after applying the default naming convention.
-   *
-   * @example
-   * resolver.resolveEnumKeyTypedName(node) // → 'PetStatusKey'
-   */
-  resolveEnumKeyTypedName(node: SchemaNode): string;
-  /**
-   * Resolves the variable/function name for an operation's grouped path parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamName` per individual parameter instead.
-   * @example
-   * resolver.resolvePathParamsName(node) // → 'GetPetByIdPathParams'
-   */
-  resolvePathParamsName?(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an operation's grouped path parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamTypedName` per individual parameter instead.
-   * @example
-   * resolver.resolvePathParamsTypedName(node) // → 'GetPetByIdPathParams'
-   */
-  resolvePathParamsTypedName?(node: OperationNode): string;
-  /**
-   * Resolves the variable/function name for an operation's grouped query parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamName` per individual parameter instead.
-   * @example
-   * resolver.resolveQueryParamsName(node) // → 'FindPetsByStatusQueryParams'
-   */
-  resolveQueryParamsName?(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an operation's grouped query parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamTypedName` per individual parameter instead.
-   * @example
-   * resolver.resolveQueryParamsTypedName(node) // → 'FindPetsByStatusQueryParams'
-   */
-  resolveQueryParamsTypedName?(node: OperationNode): string;
-  /**
-   * Resolves the variable/function name for an operation's grouped header parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamName` per individual parameter instead.
-   * @example
-   * resolver.resolveHeaderParamsName(node) // → 'DeletePetHeaderParams'
-   */
-  resolveHeaderParamsName?(node: OperationNode): string;
-  /**
-   * Resolves the TypeScript type alias name for an operation's grouped header parameters type.
-   * Only available with `compatibilityPreset: 'kubbV4'`.
-   *
-   * @deprecated Kubb v4 compatibility only — use `resolveParamTypedName` per individual parameter instead.
-   * @example
-   * resolver.resolveHeaderParamsTypedName(node) // → 'DeletePetHeaderParams'
-   */
-  resolveHeaderParamsTypedName?(node: OperationNode): string;
-};
-type BuildParamsSchemaOptions = {
-  params: Array<ParameterNode>;
-  node: OperationNode;
-  resolver: ResolverTs;
-};
-type BuildOperationSchemaOptions = {
-  node: OperationNode;
-  resolver: ResolverTs;
-};
-/**
- * The concrete builder type for `@kubb/plugin-ts`.
- * Extends the base `Builder` with schema-building helpers used by the v5 type generator.
- */
-type BuilderTs = Builder & {
-  buildParams(options: BuildParamsSchemaOptions): SchemaNode;
-  buildData(options: BuildOperationSchemaOptions): SchemaNode;
-  buildResponses(options: BuildOperationSchemaOptions): SchemaNode | null;
-  buildResponseUnion(options: BuildOperationSchemaOptions): SchemaNode | null;
-};
-type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'types', barrelType: 'named' }
-   */
-  output?: Output;
-  /**
-   * Define which contentType should be used.
-   * By default, uses the first valid JSON media type.
-   */
-  contentType?: 'application/json' | (string & {});
-  /**
-   * Group the clients based on the provided name.
-   */
-  group?: Group;
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>;
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>;
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>;
-  /**
-   * Choose to use enum, asConst, asPascalConst, constEnum, literal, or inlineLiteral for enums.
-   * - 'enum' generates TypeScript enum declarations.
-   * - 'asConst' generates const objects with camelCase names and as const assertion.
-   * - 'asPascalConst' generates const objects with PascalCase names and as const assertion.
-   * - 'constEnum' generates TypeScript const enum declarations.
-   * - 'literal' generates literal union types.
-   * - 'inlineLiteral' inline enum values directly into the type (default in v5).
-   * @default 'asConst'
-   * @note In Kubb v5, 'inlineLiteral' becomes the default.
-   */
-  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral';
-  /**
-   * Choose the casing for enum key names.
-   * - 'screamingSnakeCase' generates keys in SCREAMING_SNAKE_CASE format.
-   * - 'snakeCase' generates keys in snake_case format.
-   * - 'pascalCase' generates keys in PascalCase format.
-   * - 'camelCase' generates keys in camelCase format.
-   * - 'none' uses the enum value as-is without transformation.
-   * @default 'none'
-   */
-  enumKeyCasing?: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none';
-  /**
-   * Switch between type or interface for creating TypeScript types.
-   * - 'type' generates type alias declarations.
-   * - 'interface' generates interface declarations.
-   * @default 'type'
-   */
-  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).
-   * @default 'questionToken'
-   */
-  optionalType?: 'questionToken' | 'undefined' | 'questionTokenAndUndefined';
-  /**
-   * Choose between Array<string> or string[] for array types.
-   * - 'generic' generates Array<Type> syntax.
-   * - 'array' generates Type[] syntax.
-   * @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>>;
-  /**
-   * Apply a compatibility naming preset.
-   * Use `kubbV4` for strict v4 type-generation compatibility.
-   * You can further customize naming with `resolvers`.
-   * @default 'default'
-   */
-  compatibilityPreset?: CompatibilityPreset;
-  /**
-   * Array of named resolvers that control naming conventions.
-   * Later entries override earlier ones (last wins).
-   * Built-in: `resolverTs` (default), `resolverTsLegacy`.
-   * @default [resolverTs]
-   */
-  resolvers?: Array<ResolverTs>;
-  /**
-   * Array of AST visitors applied to each SchemaNode/OperationNode before printing.
-   * Uses `transform()` from `@kubb/ast` — visitors can modify, replace, or annotate nodes.
-   *
-   * @example Remove writeOnly properties from response types
-   * ```ts
-   * transformers: [{
-   *   property(node) {
-   *     if (node.schema.writeOnly) return undefined
-   *   }
-   * }]
-   * ```
-   *
-   * @example Force all dates to plain strings
-   * ```ts
-   * transformers: [{
-   *   schema(node) {
-   *     if (node.type === 'date') return { ...node, type: 'string' }
-   *   }
-   * }]
-   * ```
-   */
-  transformers?: Array<Visitor>;
-};
-type ResolvedOptions = {
-  output: Output;
-  group: Options['group'];
-  enumType: NonNullable<Options['enumType']>;
-  enumKeyCasing: NonNullable<Options['enumKeyCasing']>;
-  optionalType: NonNullable<Options['optionalType']>;
-  arrayType: NonNullable<Options['arrayType']>;
-  syntaxType: NonNullable<Options['syntaxType']>;
-  paramsCasing: Options['paramsCasing'];
-  resolver: ResolverTs;
-  transformers: Array<Visitor>;
-};
-type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs, BuilderTs>;
-//#endregion
-export { ResolverTs as i, Options as n, PluginTs as r, BuilderTs as t };
-//# sourceMappingURL=types-BcyuFDn9.d.ts.map

package/src/builders/builderTs.ts

@@ -1,92 +0,0 @@
-import { createProperty, createSchema } from '@kubb/ast'
-import { defineBuilder } from '@kubb/core'
-import type { PluginTs } from '../types.ts'
-
-export const builderTs = defineBuilder<PluginTs>(() => ({
-  name: 'default',
-  buildParams({ params, node, resolver }) {
-    return createSchema({
-      type: 'object',
-      properties: params.map((param) =>
-        createProperty({
-          name: param.name,
-          required: param.required,
-          schema: createSchema({
-            type: 'ref',
-            name: resolver.resolveParamName(node, param),
-          }),
-        }),
-      ),
-    })
-  },
-  buildData({ node, resolver }) {
-    const pathParams = node.parameters.filter((p) => p.in === 'path')
-    const queryParams = node.parameters.filter((p) => p.in === 'query')
-    const headerParams = node.parameters.filter((p) => p.in === 'header')
-
-    return createSchema({
-      type: 'object',
-      deprecated: node.deprecated,
-      properties: [
-        createProperty({
-          name: 'data',
-          schema: node.requestBody?.schema
-            ? createSchema({ type: 'ref', name: resolver.resolveDataTypedName(node), optional: true })
-            : createSchema({ type: 'never', optional: true }),
-        }),
-        createProperty({
-          name: 'pathParams',
-          required: pathParams.length > 0,
-          schema: pathParams.length > 0 ? this.buildParams({ params: pathParams, node, resolver }) : createSchema({ type: 'never' }),
-        }),
-        createProperty({
-          name: 'queryParams',
-          schema:
-            queryParams.length > 0
-              ? createSchema({ ...this.buildParams({ params: queryParams, node, resolver }), optional: true })
-              : createSchema({ type: 'never', optional: true }),
-        }),
-        createProperty({
-          name: 'headerParams',
-          schema:
-            headerParams.length > 0
-              ? createSchema({ ...this.buildParams({ params: headerParams, node, resolver }), optional: true })
-              : createSchema({ type: 'never', optional: true }),
-        }),
-        createProperty({
-          name: 'url',
-          required: true,
-          schema: createSchema({ type: 'url', path: node.path }),
-        }),
-      ],
-    })
-  },
-  buildResponses({ node, resolver }) {
-    if (node.responses.length === 0) {
-      return null
-    }
-
-    return createSchema({
-      type: 'object',
-      properties: node.responses.map((res) =>
-        createProperty({
-          name: String(res.statusCode),
-          required: true,
-          schema: createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) }),
-        }),
-      ),
-    })
-  },
-  buildResponseUnion({ node, resolver }) {
-    const responsesWithSchema = node.responses.filter((res) => res.schema)
-
-    if (responsesWithSchema.length === 0) {
-      return null
-    }
-
-    return createSchema({
-      type: 'union',
-      members: responsesWithSchema.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
-    })
-  },
-}))

package/src/builders/index.ts

@@ -1 +0,0 @@
-export { builderTs } from './builderTs.ts'

package/src/components/index.ts

@@ -1,2 +0,0 @@
-export { Enum } from './Enum.tsx'
-export { Type } from './Type.tsx'

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export { typeGenerator } from './typeGenerator.tsx'
-export { typeGeneratorLegacy } from './typeGeneratorLegacy.tsx'

package/src/printers/index.ts

@@ -1 +0,0 @@
-export { printerTs } from './printerTs.ts'

package/src/resolvers/index.ts

@@ -1,2 +0,0 @@
-export { resolverTs } from './resolverTs.ts'
-export { resolverTsLegacy } from './resolverTsLegacy.ts'