@kubb/plugin-client 5.0.0-beta.64 → 5.7.0-canary.20260930T095256

package/dist/index.d.ts

@@ -1,127 +1,66 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
-import { Exclude, Generator, Group, Include, Output, OutputOptions, 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
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
+import "@kubb/plugin-zod";
+import "kubb/jsx";
+//#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';
+};
 /**
- * The concrete resolver type for `@kubb/plugin-client`.
- * Extends the base `Resolver` with a `resolveName` helper for client function names.
+ * 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 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;
-  /**
-   * Resolves the output file name for a client module.
-   */
-  resolvePathName(this: ResolverClient, name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  /**
-   * Resolves the generated class name for class-based clients.
-   */
-  resolveClassName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the generated class name for tag-based client groups. 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 Resolving tag-group class names
-   * `resolver.resolveGroupName('pet') // -> 'PetClient'`
-   */
-  resolveGroupName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the generated SDK facade property name for a client class.
-   */
-  resolveClientPropertyName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the URL helper function name for an operation.
-   *
-   * @example Resolving URL helper names
-   * `resolver.resolveUrlName(node) // -> 'getShowPetByIdUrl'`
-   */
-  resolveUrlName(this: ResolverClient, node: ast.OperationNode): string;
-};
+type Mode = 'tag' | 'flat';
 /**
- * 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.
+ * 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 ClientImportPath = {
-  /**
-   * HTTP client used by the generated code.
-   * - `'axios'` — imports from `@kubb/plugin-client/clients/axios`. Requires `axios` at runtime.
-   * - `'fetch'` — imports from `@kubb/plugin-client/clients/fetch`. Uses the global `fetch`.
-   *
-   * @default 'axios'
-   */
-  client?: 'axios' | 'fetch';
-  importPath?: never;
-} | {
-  client?: never;
-  /**
-   * Path to a custom client module. Generated files import their HTTP runtime from here
-   * instead of `@kubb/plugin-client/clients/{client}`. Accepts both relative paths and
-   * bare module specifiers; the value is used as-is.
-   *
-   * @note When combined with a query plugin, the module must export `Client`,
-   * `RequestConfig`, and `ResponseErrorConfig` types.
-   */
-  importPath: string;
-  /**
-   * `bundle` has no effect when `importPath` is set.
-   * Use either `bundle` (with `client`) or `importPath`, not both.
-   */
-  bundle?: never;
-};
+type ReturnTypeOption = 'full' | 'data' | 'plain';
 /**
- * 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'`).
+ * 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 ParamsTypeOptions = {
-  /**
-   * Every operation parameter (path, query, headers, body) is wrapped in a single
-   * destructured object argument.
-   */
-  paramsType: 'object';
+type ResolverClient = Resolver & {
   /**
-   * `pathParamsType` has no effect when `paramsType` is `'object'`.
-   * Path params already live inside the single destructured object.
+   * Resolves the generated class name for class-based clients.
    */
-  pathParamsType?: never;
-} | {
+  className(this: ResolverClient, name: string): string;
   /**
-   * Each parameter group is emitted as a separate positional function argument.
+   * 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.
    *
-   * @default 'inline'
+   * @example
+   * `resolver.groupName('pet') // -> 'PetClient'`
    */
-  paramsType?: 'inline';
+  groupName(this: ResolverClient, name: string): string;
   /**
-   * How URL path parameters are arranged inside the inline argument list.
-   * - `'object'` groups them into one destructured object: `{ petId }: PathParams`.
-   * - `'inline'` emits each path param as its own argument: `petId: string`.
-   *
-   * @default 'inline'
+   * Resolves the property name a tag client is exposed under on the composed root SDK
+   * (`new PetStore(config).pet`).
    */
-  pathParamsType?: 'object' | 'inline';
+  propertyName(this: ResolverClient, name: string): string;
 };
 /**
- * Where the generated client files are written and how they are exported, plus the optional
- * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
- *
- * @default { path: 'clients', barrel: { type: 'named' } }
+ * 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 = OutputOptions & {
+type Options$1 = OutputOptions & {
   /**
    * Skip operations matching at least one entry in the list.
    */
@@ -133,299 +72,181 @@ type Options = OutputOptions & {
   /**
    * Apply a different options object to operations matching a pattern.
    */
-  override?: Array<Override<ResolvedOptions>>;
-  /**
-   * Emit an `operations.ts` file that re-exports every generated function grouped by HTTP method.
-   *
-   * @default false
-   */
-  operations?: boolean;
-  /**
-   * Whether to also export the URL builder helpers (`get<Operation>Url`).
-   * - `'export'` exposes them via the barrel.
-   * - `false` keeps them private.
-   *
-   * @default false
-   */
-  urlType?: 'export' | false;
+  override?: Array<Override<Omit<ResolvedOptions$1, 'throwOnErrorDefault'>>>;
   /**
-   * Base URL prepended to every request. When omitted, falls back to the adapter's
-   * server URL (typically `servers[0].url`).
+   * Base URL prepended to every request. When omitted, falls back to the adapter's server URL.
+   * Values containing a `${...}` interpolation are emitted as template literals in the generated
+   * client config, which keeps runtime environment reads dynamic.
    */
   baseURL?: string;
   /**
-   * Shape of the value returned by each generated client function.
-   * - `'data'` — only the response body.
-   * - `'full'` — the full response as a discriminated union keyed by HTTP status code.
-   *   Each member is `{ status: N; data: StatusNType; statusText: string }`,
-   *   so narrowing on `res.status` also narrows `res.data` to the matching response type.
-   *
-   * @default 'data'
-   */
-  dataReturnType?: 'data' | 'full';
-  /**
-   * Rename parameter properties in the generated client (path, query, headers).
-   * The HTTP request still uses the original spec names; Kubb writes the mapping for you.
+   * Default error behavior for generated operations and their client. Per-call `throwOnError`
+   * takes precedence.
    *
-   * @note Use the same value on `@kubb/plugin-ts` so types stay compatible.
+   * @default true
    */
-  paramsCasing?: 'camelcase';
+  throwOnErrorDefault?: boolean;
   /**
-   * Validator applied to request and response bodies using schemas from `@kubb/plugin-zod`.
-   * - `false` (default): no validation. The response is returned as-is.
-   * - `'zod'`: validates response bodies only (backward-compatible shorthand).
-   * - `{ request?: 'zod'; response?: 'zod' }`: opt in per direction. `request` validates the
-   *   request body and query parameters before the call. `response` validates the response body.
+   * Validate request and response bodies with schemas from `@kubb/plugin-zod`.
    *
    * @default false
-   * @example Response only (shorthand)
-   * `parser: 'zod'`
-   * @example Both directions
-   * `parser: { request: 'zod', response: 'zod' }`
-   */
-  parser?: false | 'zod' | {
-    request?: 'zod';
-    response?: 'zod';
-  };
-  /**
-   * Shape of the generated client.
-   * - `'function'` — one standalone async function per operation.
-   * - `'class'` — one class per tag with instance methods.
-   * - `'staticClass'` — one class per tag with static methods.
-   *
-   * @default 'function'
-   * @note Only `'function'` is compatible with query plugins.
    */
-  clientType?: 'function' | 'class' | 'staticClass';
+  validator?: ValidatorOptions;
   /**
-   * Copy the HTTP client runtime into the generated output so consumers do not need
-   * `@kubb/plugin-client` at runtime. When `false`, generated files import from
-   * `@kubb/plugin-client/clients/{client}`.
+   * 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 false
+   * @default 'full'
+   * @example
+   * ```ts
+   * pluginAxios({ returnType: 'data' })
+   * // const pet = await getPetById({ path: { petId: 1 } }) // Pet, not { status, data, ... }
+   * ```
    */
-  bundle?: boolean;
+  returnType?: ReturnTypeOption;
   /**
-   * Generate a single SDK class composing every tag-based client into one entry point.
-   * Automatically enables `clientType: 'class'`.
+   * 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
+   * @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
-   * pluginClient({
-   *   sdk: { className: 'PetStoreSDK' },
-   * })
-   * // class PetStoreSDK {
-   * //   readonly petClient: PetClient
-   * //   readonly storeClient: StoreClient
+   * 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?: {
     /**
-     * Name of the generated SDK facade class. Also the file name.
+     * 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.
      */
-    className: string;
+    name?: string;
   };
   /**
-   * Override how names and file paths are built for the generated client.
-   * Methods you omit fall back to the default resolver. `this` is bound to the
-   * full resolver, so `this.default(name)` delegates to the built-in implementation.
+   * Override how names and file paths are built. Methods you omit fall back to the default resolver.
    */
-  resolver?: Partial<ResolverClient> & ThisType<ResolverClient>;
+  resolver?: ResolverPatch<ResolverClient>;
   /**
    * Macros applied to each operation node before code is printed.
-   * Return `null` or `undefined` from a callback to leave the node unchanged.
    */
   macros?: Array<ast.Macro>;
-  /**
-   * Custom generators that run alongside the built-in client generators.
-   */
-  generators?: Array<Generator<PluginClient>>;
-} & ClientImportPath & ParamsTypeOptions;
-type ResolvedOptions = {
+};
+/**
+ * The resolved options after defaults are applied.
+ */
+type ResolvedOptions$1 = {
   output: Output;
   exclude: Array<Exclude>;
   include: Array<Include> | undefined;
-  override: Array<Override<ResolvedOptions>>;
+  override: Array<Override<Omit<ResolvedOptions$1, 'throwOnErrorDefault'>>>;
   group: Group | null;
-  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'];
+  baseURL: Options$1['baseURL'];
+  throwOnErrorDefault: boolean;
+  validator: NonNullable<Options$1['validator']>;
+  returnType: ReturnTypeOption;
+  sdk: {
+    mode: Mode;
+    name: string | undefined;
+  } | undefined;
   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 | null | 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 | null;
-  children?: KubbReactNode;
-};
-declare function Client({
-  name,
-  isExportable,
-  isIndexable,
-  returnType,
-  baseURL,
-  dataReturnType,
-  parser,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  node,
-  tsResolver,
-  zodResolver,
-  urlName,
-  children,
-  isConfigurable
-}: Props): KubbReactNode;
-//#endregion
-//#region src/generators/classClientGenerator.d.ts
-/**
- * Built-in `operations` generator for `@kubb/plugin-client` when
- * `clientType: 'class'`. Emits one class per tag, with one instance method
- * per operation and a shared constructor for request configuration.
- */
-declare const classClientGenerator: import("@kubb/core").Generator<PluginClient, unknown>;
 //#endregion
-//#region src/generators/clientGenerator.d.ts
+//#region src/types.d.ts
 /**
- * Built-in operation generator for `@kubb/plugin-client`. Emits one async
- * function per OpenAPI operation, plus the matching URL helper. Used when
- * `clientType: 'function'` (the default).
+ * Omits keys from every member of a union, where the built-in `Omit` would collapse the union into one shape.
  */
-declare const clientGenerator: import("@kubb/core").Generator<PluginClient, unknown>;
-//#endregion
-//#region src/generators/groupedClientGenerator.d.ts
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 /**
- * Emits one aggregate file per tag/group when `group` is configured. Each
- * file re-exports every client function for that group, so callers can
- * `import { petController } from './gen/clients'` instead of importing
- * each operation individually.
+ * 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' })
+ * ```
  */
-declare const groupedClientGenerator: import("@kubb/core").Generator<PluginClient, unknown>;
-//#endregion
-//#region src/generators/operationsGenerator.d.ts
+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;
+};
 /**
- * Generates an `operations.ts` file that re-exports every operation grouped
- * by HTTP method. Enabled when `pluginClient({ operations: true })`. Useful
- * for building meta-tooling on top of the generated client (route
- * registries, API explorers).
+ * Options after `pluginClient` applies its defaults.
  */
-declare const operationsGenerator: import("@kubb/core").Generator<PluginClient, unknown>;
-//#endregion
-//#region src/generators/staticClassClientGenerator.d.ts
+type ResolvedOptions = ResolvedOptions$1 & {
+  importPath: string;
+};
 /**
- * Built-in `operations` generator for `@kubb/plugin-client` when
- * `clientType: 'staticClass'`. Emits one class per tag, with a static method
- * per operation so callers can use `Pet.getPetById(...)` without
- * instantiating the class.
+ * Plugin type of `@kubb/plugin-client`, registered in the Kubb plugin registry.
  */
-declare const staticClassClientGenerator: import("@kubb/core").Generator<PluginClient, unknown>;
+type PluginClient = PluginFactoryOptions<'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`. Used for driver lookups and
- * cross-plugin dependency references.
+ * Canonical plugin name for `@kubb/plugin-client`.
  */
-declare const pluginClientName = "plugin-client";
+export declare const pluginClientName = "plugin-client";
 /**
- * Generates one HTTP client function per OpenAPI operation. Each function has
- * typed path params, query params, body, and response, so callers use the API
- * like any other typed function. Ships with `axios` and `fetch` runtimes; bring
- * your own by setting `importPath`.
+ * 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
- * import { defineConfig } from 'kubb'
- * import { pluginTs } from '@kubb/plugin-ts'
- * import { pluginClient } from '@kubb/plugin-client'
- *
- * export default defineConfig({
- *   input: { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [
- *     pluginTs(),
- *     pluginClient({
- *       output: { path: './clients' },
- *       client: 'fetch',
- *     }),
- *   ],
- * })
+ * pluginClient({ importPath: '../api/client' })
  * ```
  */
-declare const pluginClient: (options?: Options | undefined) => import("@kubb/core").Plugin<PluginClient>;
-//#endregion
-//#region src/resolvers/resolverClient.d.ts
-/**
- * Default resolver used by `@kubb/plugin-client`. Decides the names and file
- * paths for every generated client function or class. Functions and files use
- * camelCase; classes and tag groups use PascalCase.
- *
- * @example Resolve client function and class names
- * ```ts
- * import { resolverClient } from '@kubb/plugin-client'
- *
- * resolverClient.default('list pets', 'function') // 'listPets'
- * resolverClient.resolveClassName('pet')          // 'Pet'
- * resolverClient.resolveGroupName('pet')          // 'PetClient'
- * resolverClient.resolveUrlName(operationNode)    // 'getShowPetByIdUrl'
- * ```
- */
-declare const resolverClient: ResolverClient;
-//#endregion
-//#region src/utils.d.ts
-type ParserOption = PluginClient['resolvedOptions']['parser'];
-/**
- * Returns `true` when any direction of the parser uses Zod (used for dependency checks).
- */
-declare function isParserEnabled(parser: ParserOption | undefined | false): boolean;
-/**
- * Returns `'zod'` when request body parsing is enabled, `null` otherwise.
- * The string shorthand `'zod'` also enables request body parsing (existing behavior).
- */
-declare function resolveRequestParser(parser: ParserOption | undefined | false): 'zod' | null;
-/**
- * Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise.
- * Only the object form `{ request: 'zod' }` enables query-params parsing.
- * The string shorthand `'zod'` does not, preserving its existing behavior.
- */
-declare function resolveQueryParamsParser(parser: ParserOption | undefined | false): 'zod' | null;
-/**
- * Returns `'zod'` when response-direction parsing is enabled, `null` otherwise.
- * `parser: 'zod'` (string shorthand) maps to response parsing and returns `'zod'`.
- */
-declare function resolveResponseParser(parser: ParserOption | undefined | false): 'zod' | null;
+export declare const pluginClient: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginClient>;
 //#endregion
-export { Client, type ClientImportPath, type PluginClient, type ResolverClient, classClientGenerator, clientGenerator, pluginClient as default, pluginClient, groupedClientGenerator, isParserEnabled, operationsGenerator, pluginClientName, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser, resolverClient, staticClassClientGenerator };
+export { type Options, type PluginClient, type ResolvedOptions, type ResolverClient, pluginClient as default };
 //# sourceMappingURL=index.d.ts.map