@kubb/plugin-react-query 5.0.0-beta.79 → 5.0.0-beta.81

package/dist/index.d.ts

@@ -1,161 +1,5 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
-//#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 and query parameters 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';
-/**
- * The resolver shared by the client plugins. Functions and files use camelCase; URL helpers get
- * a `get<Operation>Url` name.
- */
-type ResolverClient = Resolver & {
-  /**
-   * Resolves the function name for a raw operation name.
-   *
-   * @example
-   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-   */
-  resolveName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the output file name for a generated 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 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.resolveGroupName('pet') // -> 'PetClient'`
-   */
-  resolveGroupName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the property name a tag client is exposed under on the composed root SDK
-   * (`new PetStore(config).pet`).
-   */
-  resolveClientPropertyName(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<ResolvedOptions$1>>;
-  /**
-   * Base URL prepended to every request. When omitted, falls back to the adapter's server URL.
-   */
-  baseURL?: string;
-  /**
-   * Validate request and response bodies with schemas from `@kubb/plugin-zod`.
-   *
-   * @default false
-   */
-  validator?: ValidatorOptions;
-  /**
-   * 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?: Partial<ResolverClient> & ThisType<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<ResolvedOptions$1>>;
-  group: Group | null;
-  baseURL: Options$1['baseURL'];
-  validator: NonNullable<Options$1['validator']>;
-  sdk: {
-    mode: Mode;
-    name: string | undefined;
-  } | undefined;
-  resolver: ResolverClient;
-};
-//#endregion
 //#region ../../internals/client/src/resolveClient.d.ts
 /**
  * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
@@ -343,7 +187,7 @@ type Mutation = {
    * HTTP methods treated as mutations. Operations using these methods produce
    * `useMutation`-style hooks.
    *
-   * @default ['post', 'put', 'delete']
+   * @default ['post', 'put', 'patch', 'delete']
    */
   methods?: Array<string>;
   /**
@@ -387,8 +231,8 @@ type Infinite = {
 };
 type CustomOptions = {
   /**
-   * Module specifier of your custom-options hook. Imported as
-   * `import ${name} from '${importPath}'`.
+   * Module specifier of your custom-options hook. Imported as a named import,
+   * `import { ${name} } from '${importPath}'`.
    */
   importPath: string;
   /**
@@ -430,7 +274,7 @@ type Options = OutputOptions & {
   override?: Array<Override<ResolvedOptions>>;
   /**
    * Enables `useInfiniteQuery` hooks for cursor- or page-based pagination.
-   * Pass an object to configure how the cursor is read; pass `false` to skip.
+   * Pass an object to configure how the cursor is read, or pass `false` to skip.
    *
    * @default false
    */
@@ -465,17 +309,21 @@ type Options = OutputOptions & {
    * `HookOptions` type so the wrapper stays in sync with generated hooks.
    */
   customOptions?: CustomOptions;
-  /**
-   * Validator applied to response bodies before they reach the caller.
-   * - `'client'` — no validation. Trusts the API.
-   * - `'zod'` — pipes responses through schemas from `@kubb/plugin-zod`.
-   */
-  validator?: Options$1['validator'];
   /**
    * Override how hook names and file paths are built. Methods you omit fall
    * back to the default `resolverReactQuery`.
    */
   resolver?: Partial<ResolverReactQuery> & ThisType<ResolverReactQuery>;
+  /**
+   * Set to `false` to skip generating `use*` hook functions. `queryOptions`,
+   * `mutationOptions`, `queryKey`, and `mutationKey` helpers are still emitted.
+   * The resulting output uses only `@tanstack/react-query` factory imports
+   * (`queryOptions`, `infiniteQueryOptions`, `mutationOptions`) that are
+   * adapter-portable across React, Vue, Solid, and Svelte.
+   *
+   * @default false
+   */
+  hooks?: boolean;
   /**
    * Macros applied to each operation node before printing.
    */
@@ -499,9 +347,8 @@ type ResolvedOptions = {
    * The resolved contract client the generators import and call.
    */
   client: ResolvedClient;
-  validator: NonNullable<Options['validator']>;
   /**
-   * Only used for infinite
+   * Resolved infinite query configuration, or `false` when infinite queries are disabled.
    */
   infinite: NonNullable<Infinite> | false;
   suspense: Suspense | false;
@@ -510,6 +357,7 @@ type ResolvedOptions = {
   mutationKey: MutationKey | null;
   mutation: NonNullable<Required<Mutation>> | false;
   customOptions: NonNullable<Required<CustomOptions>> | null;
+  hooks: boolean;
   resolver: ResolverReactQuery;
 };
 type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options, ResolvedOptions, ResolverReactQuery>;
@@ -529,8 +377,8 @@ declare global {
 declare const pluginReactQueryName = "plugin-react-query";
 /**
  * Generates one TanStack Query hook per OpenAPI operation for React. Queries
- * become `useFooQuery`/`useFooSuspenseQuery`/`useFooInfiniteQuery`; mutations
- * become `useFooMutation`. Each hook is fully typed: query keys, input
+ * become `useFoo`, with `useFooSuspense` and `useFooInfinite` variants.
+ * Mutations become `useFoo`. Each hook is fully typed: query keys, input
  * variables, response data, and error shape all come from the spec.
  *
  * @example