@kubb/plugin-client 5.0.0-alpha.8 → 5.0.0-beta.3

package/dist/index.d.ts

@@ -1,10 +1,330 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as Options, r as PluginClient, t as ClientImportPath } from "./types-DBQdg-BV.js";
-import * as _kubb_core0 from "@kubb/core";
+import * as _$_kubb_core0 from "@kubb/core";
+import { Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
+import { ResolverTs } from "@kubb/plugin-ts";
+import { ResolverZod } from "@kubb/plugin-zod";
+import { KubbReactNode } from "@kubb/renderer-jsx/types";
 
+//#region src/types.d.ts
+/**
+ * The concrete resolver type for `@kubb/plugin-client`.
+ * Extends the base `Resolver` with a `resolveName` helper for client function names.
+ */
+type ResolverClient = Resolver & {
+  /**
+   * Resolves the function name for a given raw operation name.
+   * @example Resolving operation names
+   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
+   */
+  resolveName(this: ResolverClient, name: string): string;
+};
+/**
+ * Use either a preset `client` type OR a custom `importPath`, not both.
+ * `importPath` will override the default `client` preset when both are provided.
+ * These options are mutually exclusive. `bundle` and `importPath` are also
+ * mutually exclusive since `bundle` only has effect when `importPath` is not set.
+ */
+type ClientImportPath = {
+  /**
+   * Which client should be used to do the HTTP calls.
+   * - 'axios' uses axios client for HTTP requests.
+   * - 'fetch' uses native fetch API for HTTP requests.
+   * @default 'axios'
+   */
+  client?: 'axios' | 'fetch';
+  importPath?: never;
+} | {
+  client?: never;
+  /**
+   * Client import path for API calls.
+   * Used as `import client from '${importPath}'`.
+   * Accepts relative and absolute paths; path changes are not performed.
+   */
+  importPath: string;
+  /**
+   * `bundle` has no effect when `importPath` is set.
+   * Use either `bundle` (with `client`) or `importPath`, not both.
+   */
+  bundle?: never;
+};
+/**
+ * Discriminated union that ties `pathParamsType` to the `paramsType` values where it is meaningful.
+ *
+ * - `paramsType: 'object'` — all parameters (including path params) are merged into a single
+ *   destructured object. `pathParamsType` is never reached in this code path and has no effect.
+ * - `paramsType?: 'inline'` (or omitted) — each parameter group is a separate function argument.
+ *   `pathParamsType` controls whether the path-param group itself is destructured (`'object'`)
+ *   or spread as individual arguments (`'inline'`).
+ */
+type ParamsTypeOptions = {
+  /**
+   * All parameters — path, query, headers, and body — are merged into a single
+   * destructured object argument.
+   * - 'object' returns the params and pathParams as an object.
+   * @default 'inline'
+   */
+  paramsType: 'object';
+  /**
+   * `pathParamsType` has no effect when `paramsType` is `'object'`.
+   * Path params are already inside the single destructured object.
+   */
+  pathParamsType?: never;
+} | {
+  /**
+   * Each parameter group is emitted as a separate function argument.
+   * - 'inline' returns the params as comma separated params.
+   * @default 'inline'
+   */
+  paramsType?: 'inline';
+  /**
+   * Controls how path parameters are arranged within the inline argument list.
+   * - 'object' groups path params into a destructured object: `{ petId }: PathParams`.
+   * - 'inline' emits each path param as its own argument: `petId: string`.
+   * @default 'inline'
+   */
+  pathParamsType?: 'object' | 'inline';
+};
+type Options = {
+  /**
+   * Specify the export location for the files and define the behavior of the output.
+   * @default { path: 'clients', barrelType: 'named' }
+   */
+  output?: Output;
+  /**
+   * 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>>;
+  /**
+   * Create `operations.ts` file with all operations grouped by methods.
+   * @default false
+   */
+  operations?: boolean;
+  /**
+   * Export urls that are used by operation x.
+   * - 'export' makes them part of your barrel file.
+   * - false does not make them exportable.
+   * @default false
+   * @example getGetPetByIdUrl
+   */
+  urlType?: 'export' | false;
+  /**
+   * Allows you to set a custom base url for all generated calls.
+   */
+  baseURL?: string;
+  /**
+   * ReturnType that is used when calling the client.
+   * - 'data' returns ResponseConfig[data].
+   * - 'full' returns ResponseConfig.
+   * @default 'data'
+   */
+  dataReturnType?: 'data' | 'full';
+  /**
+   * How to style your params, by default no casing is applied.
+   * - 'camelcase' uses camelCase for pathParams, queryParams and headerParams names
+   * @note response types (data/body) are not affected by this option
+   */
+  paramsCasing?: 'camelcase';
+  /**
+   * Which parser can be used before returning the data.
+   * - 'client' returns the data as-is from the client.
+   * - 'zod' uses @kubb/plugin-zod to parse the data.
+   * @default 'client'
+   */
+  parser?: 'client' | 'zod';
+  /**
+   * How to generate the client code.
+   * - 'function' generates standalone functions for each operation.
+   * - 'class' generates a class with methods for each operation.
+   * - 'staticClass' generates a class with static methods for each operation.
+   * @default 'function'
+   */
+  clientType?: 'function' | 'class' | 'staticClass';
+  /**
+   * Bundle the selected client into the generated `.kubb` directory.
+   * When disabled the generated clients will import the shared runtime from `@kubb/plugin-client/clients/*`.
+   * @default false
+   * In version 5 of Kubb this is by default true
+   */
+  bundle?: boolean;
+  /**
+   * Generate an SDK facade class that composes all tag-based client classes into a single entry point.
+   * Setting this option automatically enables `clientType: 'class'`.
+   * @example
+   * ```ts
+   * pluginClient({
+   *   sdk: { className: 'PetStoreSDK' },
+   * })
+   * // Generates a class with a shared constructor config and one property per tag:
+   * // class PetStoreSDK {
+   * //   readonly petController: petController
+   * //   readonly storeController: storeController
+   * //   constructor(config = {}) { ... }
+   * // }
+   * ```
+   */
+  sdk?: {
+    /**
+     * Name of the generated SDK facade class.
+     */
+    className: string;
+  };
+  /**
+   * Override individual resolver methods. Any method you omit falls back to the
+   * preset resolver's implementation. Use `this.default(...)` to call it.
+   */
+  resolver?: Partial<ResolverClient> & ThisType<ResolverClient>;
+  /**
+   * Single AST visitor applied to each node before printing.
+   * Return `null` or `undefined` from a method to leave the node unchanged.
+   */
+  transformer?: ast.Visitor;
+  /**
+   * Define some generators next to the client generators.
+   */
+  generators?: Array<Generator<PluginClient>>;
+} & ClientImportPath & ParamsTypeOptions;
+type ResolvedOptions = {
+  output: Output;
+  exclude: Array<Exclude>;
+  include: Array<Include> | undefined;
+  override: Array<Override<ResolvedOptions>>;
+  group: Group | undefined;
+  client: Options['client'];
+  clientType: NonNullable<Options['clientType']>;
+  bundle: NonNullable<Options['bundle']>;
+  parser: NonNullable<Options['parser']>;
+  urlType: NonNullable<Options['urlType']>;
+  importPath: Options['importPath'];
+  baseURL: Options['baseURL'];
+  dataReturnType: NonNullable<Options['dataReturnType']>;
+  pathParamsType: NonNullable<NonNullable<Options['pathParamsType']>>;
+  paramsType: NonNullable<Options['paramsType']>;
+  paramsCasing: Options['paramsCasing'];
+  sdk: Options['sdk'];
+  resolver: ResolverClient;
+};
+type PluginClient = PluginFactoryOptions<'plugin-client', Options, ResolvedOptions, ResolverClient>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-client': PluginClient;
+    }
+  }
+}
+//#endregion
+//#region src/components/Client.d.ts
+type Props = {
+  name: string;
+  urlName?: string;
+  isExportable?: boolean;
+  isIndexable?: boolean;
+  isConfigurable?: boolean;
+  returnType?: string;
+  baseURL: string | undefined;
+  dataReturnType: PluginClient['resolvedOptions']['dataReturnType'];
+  paramsCasing: PluginClient['resolvedOptions']['paramsCasing'];
+  paramsType: PluginClient['resolvedOptions']['pathParamsType'];
+  pathParamsType: PluginClient['resolvedOptions']['pathParamsType'];
+  parser: PluginClient['resolvedOptions']['parser'] | undefined;
+  node: ast.OperationNode;
+  tsResolver: ResolverTs;
+  zodResolver?: ResolverZod;
+  children?: KubbReactNode;
+};
+type GetParamsProps = {
+  paramsCasing: PluginClient['resolvedOptions']['paramsCasing'];
+  paramsType: PluginClient['resolvedOptions']['paramsType'];
+  pathParamsType: PluginClient['resolvedOptions']['pathParamsType'];
+  node: ast.OperationNode;
+  tsResolver: ResolverTs;
+  isConfigurable: boolean;
+};
+declare function Client({
+  name,
+  isExportable,
+  isIndexable,
+  returnType,
+  baseURL,
+  dataReturnType,
+  parser,
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+  node,
+  tsResolver,
+  zodResolver,
+  urlName,
+  children,
+  isConfigurable
+}: Props): KubbReactNode;
+declare namespace Client {
+  var getParams: ({
+    paramsType,
+    paramsCasing,
+    pathParamsType,
+    node,
+    tsResolver,
+    isConfigurable
+  }: GetParamsProps) => ast.FunctionParametersNode;
+}
+//#endregion
+//#region src/generators/classClientGenerator.d.ts
+declare const classClientGenerator: _$_kubb_core0.Generator<PluginClient, unknown>;
+//#endregion
+//#region src/generators/clientGenerator.d.ts
+declare const clientGenerator: _$_kubb_core0.Generator<PluginClient, unknown>;
+//#endregion
+//#region src/generators/groupedClientGenerator.d.ts
+declare const groupedClientGenerator: _$_kubb_core0.Generator<PluginClient, unknown>;
+//#endregion
+//#region src/generators/operationsGenerator.d.ts
+declare const operationsGenerator: _$_kubb_core0.Generator<PluginClient, unknown>;
+//#endregion
+//#region src/generators/staticClassClientGenerator.d.ts
+declare const staticClassClientGenerator: _$_kubb_core0.Generator<PluginClient, unknown>;
+//#endregion
 //#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-client`, used in driver lookups and warnings.
+ */
 declare const pluginClientName = "plugin-client";
-declare const pluginClient: (options?: Options | undefined) => _kubb_core0.UserPluginWithLifeCycle<PluginClient>;
+/**
+ * Generates type-safe HTTP client functions or classes from an OpenAPI specification.
+ * Creates client APIs by walking operations and delegating to generators.
+ * Writes barrel files based on the configured `barrelType`.
+ *
+ * @example Client generator
+ * ```ts
+ * import pluginClient from '@kubb/plugin-client'
+ * export default defineConfig({
+ *   plugins: [pluginClient({ output: { path: 'clients' } })]
+ * })
+ * ```
+ */
+declare const pluginClient: (options?: Options | undefined) => _$_kubb_core0.Plugin<PluginClient>;
+//#endregion
+//#region src/resolvers/resolverClient.d.ts
+/**
+ * Naming convention resolver for client plugin.
+ *
+ * Provides default naming helpers using camelCase for functions and file paths.
+ *
+ * @example
+ * `resolverClient.default('list pets', 'function')  // → 'listPets'`
+ */
+declare const resolverClient: ResolverClient;
 //#endregion
-export { type ClientImportPath, type PluginClient, pluginClient, pluginClientName };
+export { Client, type ClientImportPath, type PluginClient, type ResolverClient, classClientGenerator, clientGenerator, pluginClient as default, pluginClient, groupedClientGenerator, operationsGenerator, pluginClientName, resolverClient, staticClassClientGenerator };
 //# sourceMappingURL=index.d.ts.map