@kubb/plugin-client 5.5.12 → 5.5.14

package/dist/index.cjs

@@ -439,11 +439,11 @@ function createGroupConfig(group) {
 //#region kubb-extension.json
 var compatibility = {
 	"kubb": ">=5.8.3",
-	"node": ">=22"
+	"node": ">=22.12"
 };
 //#endregion
 //#region package.json
-var version = "5.5.12";
+var version = "5.5.14";
 //#endregion
 //#region ../../internals/client/src/builders/validatorOptions.ts
 /**

package/dist/index.d.cts

@@ -0,0 +1,251 @@
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+import "@kubb/plugin-zod";
+//#region ../../internals/client/src/types.d.ts
+/**
+ * Validator applied to request and response bodies using schemas from `@kubb/plugin-zod`.
+ * - `false`: no validation.
+ * - `'zod'`: validates the success (2xx) response body, and the error body when a non-2xx call does
+ *   not throw (`throwOnError: false`).
+ * - `{ request?: 'zod'; response?: 'zod' }`: opt in per direction. `request` validates the request
+ *   body before the call; `response` validates the success response body and,
+ *   on the non-throw path, the error body.
+ */
+type ValidatorOptions = false | 'zod' | {
+  request?: 'zod';
+  response?: 'zod';
+};
+/**
+ * How the class-based SDK groups operations.
+ * - `'tag'`: one class per tag, optionally composed into a root client.
+ * - `'flat'`: one class with every operation as a direct method.
+ */
+type Mode = 'tag' | 'flat';
+/**
+ * Shape of the value a generated operation function resolves to.
+ * - `'full'`: the complete `{ status, data, error, contentType, request, response }` result.
+ * - `'data'`: the bare success body when `throwOnError` is true, or the full result when it is false
+ *   so callers can inspect `error`.
+ * - `'plain'`: the client's own promise typed as `RequestResult`, with no `withUnwrap` / `unwrapResult`
+ *   helper. Backs `@kubb/plugin-client`.
+ */
+type ReturnTypeOption = 'full' | 'data' | 'plain';
+/**
+ * The resolver shared by the client plugins. Inherits the built-in camelCase `name` and `file`;
+ * classes and tag groups use PascalCase (with a `Client` suffix for groups).
+ */
+type ResolverClient = Resolver & {
+  /**
+   * Resolves the generated class name for class-based clients.
+   */
+  className(this: ResolverClient, name: string): string;
+  /**
+   * Resolves the generated class name for a tag-based client group. The default appends a
+   * `Client` suffix (tag `pet` becomes `PetClient`) so the class never collides with the schema
+   * model of the same name in the barrel.
+   *
+   * @example
+   * `resolver.groupName('pet') // -> 'PetClient'`
+   */
+  groupName(this: ResolverClient, name: string): string;
+  /**
+   * Resolves the property name a tag client is exposed under on the composed root SDK
+   * (`new PetStore(config).pet`).
+   */
+  propertyName(this: ResolverClient, name: string): string;
+};
+/**
+ * The shared options surface for the client plugins. Deliberately small: there is one
+ * response contract and one grouped options object. Each plugin extends this with its own
+ * `transport` field.
+ */
+type Options$1 = OutputOptions & {
+  /**
+   * Skip operations matching at least one entry in the list.
+   */
+  exclude?: Array<Exclude>;
+  /**
+   * Restrict generation to operations matching at least one entry in the list.
+   */
+  include?: Array<Include>;
+  /**
+   * Apply a different options object to operations matching a pattern.
+   */
+  override?: Array<Override<Omit<ResolvedOptions$1, 'throwOnErrorDefault'>>>;
+  /**
+   * Base URL prepended to every request. When omitted, the generated client sets no base URL, so
+   * set one at runtime with `client.setConfig({ baseURL })`. The adapter's server URL is not used.
+   * Values containing a `${...}` interpolation are emitted as template literals in the generated
+   * client config, which keeps runtime environment reads dynamic.
+   */
+  baseURL?: string;
+  /**
+   * Default error behavior for generated operations and their client. Per-call `throwOnError`
+   * takes precedence.
+   *
+   * @default true
+   */
+  throwOnErrorDefault?: boolean;
+  /**
+   * Validate request and response bodies with schemas from `@kubb/plugin-zod`.
+   *
+   * @default false
+   */
+  validator?: ValidatorOptions;
+  /**
+   * Shape of the value a generated operation function resolves to. Applies to the standalone
+   * functions and the class-based SDK; not to the query-hook plugins (`@kubb/plugin-react-query`,
+   * `@kubb/plugin-vue-query`, `@kubb/plugin-swr`), which keep calling the client directly and
+   * expect the full result.
+   *
+   * @default 'full'
+   * @example
+   * ```ts
+   * pluginAxios({ returnType: 'data' })
+   * // const pet = await getPetById({ path: { petId: 1 } }) // Pet, not { status, data, ... }
+   * ```
+   */
+  returnType?: ReturnTypeOption;
+  /**
+   * Generates a class-based SDK instead of the standalone functions. Each tag client is an instance
+   * class whose constructor takes a client config and builds its own client, so every environment is
+   * a separate instance. Leave `sdk` unset to keep the standalone per-operation functions (the
+   * default), which is also what query plugins consume.
+   *
+   * @example Instance class per tag
+   * ```ts
+   * pluginFetch({ sdk: {} })
+   * // const api = new PetClient({ baseURL: 'https://api.example.com' })
+   * // await api.getPetById({ path: { petId: 1 } })
+   * ```
+   * @example Composed root that instantiates every tag client from one config
+   * ```ts
+   * pluginFetch({ sdk: { name: 'petStore' } })
+   * // class PetStore {
+   * //   readonly pet: PetClient
+   * //   readonly store: StoreClient
+   * //   constructor(config = {}) { ... }
+   * // }
+   * // const api = new PetStore({ baseURL })
+   * // await api.pet.getPetById({ path: { petId: 1 } })
+   * ```
+   * @example Flat class with every operation as a direct method
+   * ```ts
+   * pluginFetch({ sdk: { name: 'petStore', mode: 'flat' } })
+   * // const api = new PetStore({ baseURL })
+   * // await api.getPetById({ path: { petId: 1 } })
+   * ```
+   */
+  sdk?: {
+    /**
+     * How the SDK groups operations.
+     * - `'tag'`: one class per tag. With `name`, a composed root instantiates every tag client.
+     * - `'flat'`: one class named by `name`, with every operation as a direct method.
+     *
+     * @default 'tag'
+     */
+    mode?: Mode;
+    /**
+     * Name of the generated entry point, also the file name. With `mode: 'tag'` it emits a
+     * composed root class that instantiates every tag client from one shared config. With
+     * `mode: 'flat'` it names the single class.
+     */
+    name?: string;
+  };
+  /**
+   * Override how names and file paths are built. Methods you omit fall back to the default resolver.
+   */
+  resolver?: ResolverPatch<ResolverClient>;
+  /**
+   * Macros applied to each operation node before code is printed.
+   */
+  macros?: Array<ast.Macro>;
+};
+/**
+ * The resolved options after defaults are applied.
+ */
+type ResolvedOptions$1 = {
+  output: Output;
+  exclude: Array<Exclude>;
+  include: Array<Include> | undefined;
+  override: Array<Override<Omit<ResolvedOptions$1, 'throwOnErrorDefault'>>>;
+  group: Group | null;
+  baseURL: Options$1['baseURL'];
+  throwOnErrorDefault: boolean;
+  validator: NonNullable<Options$1['validator']>;
+  returnType: ReturnTypeOption;
+  sdk: {
+    mode: Mode;
+    name: string | undefined;
+  } | undefined;
+  resolver: ResolverClient;
+};
+//#endregion
+//#region src/types.d.ts
+/**
+ * Omits keys from every member of a union, where the built-in `Omit` would collapse the union into one shape.
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Options for `pluginClient`. It takes the shared client options, without the ones this plugin does not use,
+ * plus the required `importPath`.
+ *
+ * @example
+ * ```ts
+ * pluginClient({ importPath: '../../../client' })
+ * ```
+ */
+type Options = DistributiveOmit<Options$1, 'sdk' | 'returnType' | 'baseURL' | 'override'> & {
+  /**
+   * Applies different options to operations that match a pattern.
+   * `sdk`, `returnType`, and `baseURL` are not available, because this plugin generates standalone operations and your client module owns the base URL.
+   */
+  override?: Array<Override<Omit<ResolvedOptions, 'throwOnErrorDefault' | 'sdk' | 'returnType' | 'baseURL'>>>;
+  /**
+   * Import specifier of your own client module, written into every generated import exactly as given.
+   * It must resolve from the generated file, so use a relative path, a package name, or an alias.
+   *
+   * @example
+   * ```ts
+   * pluginClient({ importPath: '../../../client' }) // relative to src/gen/clients/<tag>/
+   * pluginClient({ importPath: '@my-org/api-client' }) // a package
+   * ```
+   */
+  importPath: string;
+};
+/**
+ * Options after `pluginClient` applies its defaults.
+ */
+type ResolvedOptions = ResolvedOptions$1 & {
+  importPath: string;
+};
+/**
+ * Plugin type of `@kubb/plugin-client`, registered in the Kubb plugin registry.
+ */
+type PluginClient = PluginType<'plugin-client', Options, ResolvedOptions, ResolverClient>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-client': PluginClient;
+    }
+  }
+}
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-client`.
+ */
+export declare const pluginClientName = "plugin-client";
+/**
+ * Generates typed operations that call a client module owned by your application.
+ * The module at `importPath` must export the runtime helpers and types used by generated operations.
+ * Kubb does not copy or inject a transport implementation.
+ *
+ * @example
+ * ```ts
+ * pluginClient({ importPath: '../api/client' })
+ * ```
+ */
+export declare const pluginClient: import("kubb/kit").PluginFactory<PluginClient>;
+//#endregion
+export { type Options, type PluginClient, type ResolvedOptions, type ResolverClient, pluginClient as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Diagnostics, Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
 import "@kubb/plugin-zod";
 //#region ../../internals/client/src/types.d.ts
 /**

package/dist/index.js

@@ -1,10 +1,10 @@
-import "./rolldown-runtime-C0LytTxp.js";
 import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, macroSimplifyUnion, setMacros, setResolver } from "kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, jsxRenderer } from "kubb/jsx";
 import { jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -413,11 +413,11 @@ function createGroupConfig(group) {
 //#region kubb-extension.json
 var compatibility = {
 	"kubb": ">=5.8.3",
-	"node": ">=22"
+	"node": ">=22.12"
 };
 //#endregion
 //#region package.json
-var version = "5.5.12";
+var version = "5.5.14";
 //#endregion
 //#region ../../internals/client/src/builders/validatorOptions.ts
 /**

package/kubb-extension.json

@@ -21,7 +21,7 @@
   "optionalDependencies": ["plugin-zod"],
   "compatibility": {
     "kubb": ">=5.8.3",
-    "node": ">=22"
+    "node": ">=22.12"
   },
   "options": [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "5.5.12",
+  "version": "5.5.14",
   "description": "Generate typed API operations against your own client module.",
   "keywords": [
     "api-client",
@@ -35,9 +35,14 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./package.json": "./package.json",
     "./kubb-extension.json": "./kubb-extension.json"
@@ -47,20 +52,20 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/plugin-ts": "^5.0.12",
-    "@kubb/plugin-zod": "^5.4.10"
+    "@kubb/plugin-ts": "^5.0.14",
+    "@kubb/plugin-zod": "^5.4.12"
   },
   "devDependencies": {
     "@internals/client": "0.0.0",
     "@internals/shared": "0.0.0",
-    "kubb": "^5.10.2",
+    "kubb": "^5.10.3",
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "kubb": "^5.10.2"
+    "kubb": "^5.10.3"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=22.12"
   },
   "scripts": {
     "build": "tsdown",

package/dist/rolldown-runtime-C0LytTxp.js

@@ -1,8 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-//#endregion
-export { __name as t };