@kubb/plugin-client 5.0.0-alpha.3 → 5.0.0-alpha.31

package/dist/index.d.ts

@@ -1,10 +1,486 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as Options, r as PluginClient, t as ClientImportPath } from "./types-CdM4DK1M.js";
-import * as _kubb_core0 from "@kubb/core";
+import { PluginTs } from "@kubb/plugin-ts";
+import { FunctionParams } from "@kubb/react-fabric";
+import * as _$_kubb_core0 from "@kubb/core";
+import { CompatibilityPreset, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, ResolvePathOptions, Resolver, UserGroup } from "@kubb/core";
+import { PluginZod } from "@kubb/plugin-zod";
+import { FunctionParametersNode, OperationNode, Visitor } from "@kubb/ast/types";
+import { FabricReactNode } from "@kubb/react-fabric/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
+   * 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?: UserGroup;
+  /**
+   * 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 a wrapper class that composes all tag-based client classes into a single entry point.
+   */
+  wrapper?: {
+    /**
+     * Name of the wrapper class.
+     */
+    className: string;
+  };
+  /**
+   * Apply a compatibility naming preset.
+   * @default 'default'
+   */
+  compatibilityPreset?: CompatibilityPreset;
+  /**
+   * 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?: 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'];
+  wrapper: Options['wrapper'];
+  resolver: ResolverClient;
+};
+type PluginClient = PluginFactoryOptions<'plugin-client', Options, ResolvedOptions, never, ResolvePathOptions, ResolverClient>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-client': PluginClient;
+    }
+  }
+}
+//#endregion
+//#region src/components/Client.d.ts
+type Props$1 = {
+  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: OperationNode;
+  tsResolver: PluginTs['resolver'];
+  zodResolver?: PluginZod['resolver'];
+  children?: FabricReactNode;
+};
+type GetParamsProps$1 = {
+  paramsCasing: PluginClient['resolvedOptions']['paramsCasing'];
+  paramsType: PluginClient['resolvedOptions']['paramsType'];
+  pathParamsType: PluginClient['resolvedOptions']['pathParamsType'];
+  node: OperationNode;
+  tsResolver: PluginTs['resolver'];
+  isConfigurable: boolean;
+};
+declare function Client({
+  name,
+  isExportable,
+  isIndexable,
+  returnType,
+  baseURL,
+  dataReturnType,
+  parser,
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+  node,
+  tsResolver,
+  zodResolver,
+  urlName,
+  children,
+  isConfigurable
+}: Props$1): FabricReactNode;
+declare namespace Client {
+  var getParams: ({
+    paramsType,
+    paramsCasing,
+    pathParamsType,
+    node,
+    tsResolver,
+    isConfigurable
+  }: GetParamsProps$1) => FunctionParametersNode;
+}
+//#endregion
+//#region src/components/ClientLegacy.d.ts
+/**
+ * Structural type matching OperationSchema from @kubb/plugin-oas.
+ * Avoids importing from @kubb/oas or @kubb/plugin-oas.
+ * Uses broad types so that OperationSchemas is assignable without imports.
+ */
+type LegacyOperationSchema = {
+  name?: string;
+  schema?: Record<string, any>;
+  statusCode?: string | number;
+  [key: string]: unknown;
+};
+type LegacyOperationSchemas = {
+  pathParams?: LegacyOperationSchema;
+  queryParams?: LegacyOperationSchema;
+  headerParams?: LegacyOperationSchema;
+  request?: LegacyOperationSchema;
+  response: LegacyOperationSchema & {
+    name: string;
+  };
+  statusCodes?: Array<LegacyOperationSchema & {
+    name: string;
+  }>;
+  errors?: Array<LegacyOperationSchema & {
+    name: string;
+  }>;
+  [key: string]: unknown;
+};
+type LegacyOperation = {
+  path: string;
+  method: string;
+  getDescription?(): string | undefined;
+  getSummary?(): string | undefined;
+  isDeprecated?(): boolean;
+  getContentType?(): string;
+};
+type Props = {
+  name: string;
+  urlName?: string;
+  isExportable?: boolean;
+  isIndexable?: boolean;
+  isConfigurable?: boolean;
+  returnType?: string;
+  baseURL: string | undefined;
+  dataReturnType: 'data' | 'full';
+  paramsCasing?: 'camelcase';
+  paramsType: 'object' | 'inline';
+  pathParamsType: 'object' | 'inline';
+  parser: 'client' | 'zod' | undefined;
+  typeSchemas: LegacyOperationSchemas;
+  zodSchemas: LegacyOperationSchemas | undefined;
+  operation: LegacyOperation;
+  children?: FabricReactNode;
+};
+type GetParamsProps = {
+  paramsCasing?: 'camelcase';
+  paramsType: 'object' | 'inline';
+  pathParamsType: 'object' | 'inline';
+  typeSchemas: LegacyOperationSchemas;
+  isConfigurable: boolean;
+};
+declare function ClientLegacy({
+  name,
+  isExportable,
+  isIndexable,
+  returnType,
+  typeSchemas,
+  baseURL,
+  dataReturnType,
+  parser,
+  zodSchemas,
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+  operation,
+  urlName,
+  children,
+  isConfigurable
+}: Props): FabricReactNode;
+declare namespace ClientLegacy {
+  var getParams: ({
+    paramsType,
+    paramsCasing,
+    pathParamsType,
+    typeSchemas,
+    isConfigurable
+  }: GetParamsProps) => FunctionParams;
+}
+type UrlProps = {
+  name: string;
+  isExportable?: boolean;
+  isIndexable?: boolean;
+  baseURL: string | undefined;
+  paramsCasing?: 'camelcase';
+  paramsType: 'object' | 'inline';
+  pathParamsType: 'object' | 'inline';
+  typeSchemas: LegacyOperationSchemas;
+  operation: LegacyOperation;
+};
+type UrlGetParamsProps = {
+  paramsCasing?: 'camelcase';
+  paramsType: 'object' | 'inline';
+  pathParamsType: 'object' | 'inline';
+  typeSchemas: LegacyOperationSchemas;
+};
+declare function getUrlParams({
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+  typeSchemas
+}: UrlGetParamsProps): FunctionParams;
+declare function UrlLegacy({
+  name,
+  isExportable,
+  isIndexable,
+  typeSchemas,
+  baseURL,
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+  operation
+}: UrlProps): FabricReactNode;
+declare namespace UrlLegacy {
+  var getParams: typeof getUrlParams;
+}
+//#endregion
+//#region src/generators/classClientGenerator.d.ts
+declare const classClientGenerator: _$_kubb_core0.Generator<PluginClient>;
+//#endregion
+//#region src/generators/clientGenerator.d.ts
+declare const clientGenerator: _$_kubb_core0.Generator<PluginClient>;
+//#endregion
+//#region src/generators/groupedClientGenerator.d.ts
+declare const groupedClientGenerator: _$_kubb_core0.Generator<PluginClient>;
+//#endregion
+//#region src/generators/operationsGenerator.d.ts
+declare const operationsGenerator: _$_kubb_core0.Generator<PluginClient>;
+//#endregion
+//#region src/generators/staticClassClientGenerator.d.ts
+declare const staticClassClientGenerator: _$_kubb_core0.Generator<PluginClient>;
+//#endregion
 //#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-client`, used to identify the plugin
+ * in driver lookups and warnings.
+ */
 declare const pluginClientName = "plugin-client";
-declare const pluginClient: (options?: Options | undefined) => _kubb_core0.UserPluginWithLifeCycle<PluginClient>;
+/**
+ * The `@kubb/plugin-client` plugin factory.
+ *
+ * Generates type-safe HTTP client functions (or classes) from an OpenAPI/AST `RootNode`.
+ * Walks operations, delegates rendering to the active generators,
+ * and writes barrel files based on `output.barrelType`.
+ *
+ * @example
+ * ```ts
+ * import { pluginClient } from '@kubb/plugin-client'
+ *
+ * export default defineConfig({
+ *   plugins: [pluginClient({ output: { path: 'clients' } })],
+ * })
+ * ```
+ */
+declare const pluginClient: (options?: Options | undefined) => _$_kubb_core0.UserPluginWithLifeCycle<PluginClient>;
+//#endregion
+//#region src/presets.d.ts
+/**
+ * Built-in preset registry for `@kubb/plugin-client`.
+ *
+ * - `default` — uses `resolverClient` with v5 naming conventions.
+ * - `kubbV4`  — uses `resolverClientLegacy` with backward-compatible naming.
+ *
+ * Note: Unlike plugin-ts/plugin-zod, generators are not defined here because
+ * plugin-client selects generators dynamically based on `clientType`, `group`,
+ * and `operations` options. Generator selection happens in `plugin.ts`.
+ */
+declare const presets: _$_kubb_core0.Presets<ResolverClient>;
+//#endregion
+//#region src/resolvers/resolverClient.d.ts
+/**
+ * Resolver for `@kubb/plugin-client` that provides the default naming
+ * and path-resolution helpers used by the plugin.
+ *
+ * @example
+ * ```ts
+ * import { resolverClient } from '@kubb/plugin-client'
+ *
+ * resolverClient.default('list pets', 'function') // -> 'listPets'
+ * resolverClient.resolveName('show pet by id')    // -> 'showPetById'
+ * ```
+ */
+declare const resolverClient: ResolverClient;
+//#endregion
+//#region src/resolvers/resolverClientLegacy.d.ts
+/**
+ * Legacy resolver for `@kubb/plugin-client` that provides backward-compatible
+ * naming conventions matching the v4 behavior.
+ *
+ * @example
+ * ```ts
+ * import { resolverClientLegacy } from '@kubb/plugin-client'
+ *
+ * resolverClientLegacy.default('list pets', 'function') // -> 'listPets'
+ * resolverClientLegacy.resolveName('show pet by id')    // -> 'showPetById'
+ * ```
+ */
+declare const resolverClientLegacy: ResolverClient;
 //#endregion
-export { type ClientImportPath, type PluginClient, pluginClient, pluginClientName };
+export { Client, type ClientImportPath, ClientLegacy, type PluginClient, type ResolverClient, UrlLegacy, classClientGenerator, clientGenerator, groupedClientGenerator, operationsGenerator, pluginClient, pluginClientName, presets, resolverClient, resolverClientLegacy, staticClassClientGenerator };
 //# sourceMappingURL=index.d.ts.map