@kubb/plugin-ts 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/index.d.ts

@@ -1,55 +1,8 @@
 import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
-import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "kubb/kit";
 import { KubbReactNode } from "kubb/jsx";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
 import ts from "typescript";
 
-//#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 = {
-  /**
-   * Resolves the type name for an individual parameter.
-   *
-   * @example Individual path parameter name
-   * `resolver.resolveParamName(node, param) // → 'DeletePetPathPetId'`
-   */
-  resolveParamName(node: ast.OperationNode, param: ast.ParameterNode): string;
-  /**
-   * Resolves the request body type name.
-   *
-   * @example Request body type name
-   * `resolver.resolveDataName(node) // → 'CreatePetData'`
-   */
-  resolveDataName(node: ast.OperationNode): string;
-  /**
-   * Resolves the grouped path parameters type name.
-   * When the return value equals `resolveParamName`, no indexed access is emitted.
-   *
-   * @example Grouped path params type name
-   * `resolver.resolvePathParamsName(node, param) // → 'DeletePetPathParams'`
-   */
-  resolvePathParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
-  /**
-   * Resolves the grouped query parameters type name.
-   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
-   *
-   * @example Grouped query params type name
-   * `resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'`
-   */
-  resolveQueryParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
-  /**
-   * Resolves the grouped header parameters type name.
-   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
-   *
-   * @example Grouped header params type name
-   * `resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'`
-   */
-  resolveHeaderParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
-};
-//#endregion
 //#region src/printers/printerTs.d.ts
 /**
  * Partial map of node-type overrides for the TypeScript printer.
@@ -167,96 +120,105 @@ 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 & OperationParamsResolver & {
+type ResolverTs = Resolver & {
   /**
-   * 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'`
+   * Naming for an operation's parameters, grouped by location.
    */
-  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`).
-   *
-   * The `RequestConfig` suffix is kept through the v5 beta to avoid churn, but it overlaps with the
-   * runtime client's `RequestConfig`. Renaming to `Request` is on the table before stable.
-   *
-   * @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;
+  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'`
+   * Naming for an operation's request and response types.
    */
-  resolveQueryParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
+  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'`
+   * Naming for enum schemas.
    */
-  resolveHeaderParamsName(node: ast.OperationNode, param: ast.ParameterNode): string;
+  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';
@@ -407,10 +369,9 @@ type Options = OutputOptions & {
   /**
    * 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.
+   * full resolver, so `this.default.name(name)` delegates to the built-in implementation.
    */
-  resolver?: Partial<ResolverTs> & ThisType<ResolverTs>;
+  resolver?: ResolverPatch<ResolverTs>;
   /**
    * Macros applied to each schema or operation node before printing.
    * Callbacks you omit fall back to the preset behavior.
@@ -834,6 +795,63 @@ declare function functionPrinter(options: FunctionPrinterOptions): {
   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}.
@@ -931,19 +949,33 @@ declare function createOperationParams(node: ast.OperationNode, options: CreateO
  * to reference the exact names `plugin-ts` produces without duplicating the
  * casing/file-layout rules.
  *
- * The `default` method is supplied by `defineResolver`. It uses PascalCase for
- * type names and PascalCase file paths (dotted names become `/`-joined) for files.
+ * 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 Resolve a type and file name
  * ```ts
  * import { resolverTs } from '@kubb/plugin-ts'
  *
- * resolverTs.default('list pets', 'type')        // 'ListPets'
- * resolverTs.resolvePathName('list pets', 'file') // 'ListPets'
- * resolverTs.resolveResponseStatusName(node, 200) // 'ListPetsStatus200'
+ * resolverTs.name('list pets')                     // 'ListPets'
+ * resolverTs.response.status(node, 200)            // 'ListPetsStatus200'
  * ```
  */
 declare const resolverTs: ResolverTs;
 //#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, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, 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