@kubb/plugin-react-query 4.21.2 → 4.22.1

package/dist/generators.d.ts

@@ -1,6 +1,462 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { a as ReactGenerator, r as PluginReactQuery } from "./types-CdpInNzi.js";
+import { r as PluginReactQuery } from "./types-DoN-nl4J.js";
+import { BaseGenerator, Config, FileMetaBase, Group, KubbEvents, Output, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from "@kubb/core";
+import { AsyncEventEmitter } from "@kubb/core/utils";
+import { HttpMethod, Oas, Operation, SchemaObject, contentType } from "@kubb/oas";
+import { Fabric } from "@kubb/react-fabric";
+import { FabricReactNode } from "@kubb/react-fabric/types";
+import { KubbFile } from "@kubb/fabric-core/types";
 
+//#region ../plugin-oas/src/types.d.ts
+type GetOasOptions = {
+  validate?: boolean;
+};
+type Context$2 = {
+  getOas(options?: GetOasOptions): Promise<Oas>;
+  getBaseURL(): Promise<string | undefined>;
+};
+declare global {
+  namespace Kubb {
+    interface PluginContext extends Context$2 {}
+  }
+}
+/**
+ * `propertyName` is the ref name + resolved with the nameResolver
+ *  @example import { Pet } from './Pet'
+ *
+ * `originalName` is the original name used(in PascalCase), only used to remove duplicates
+ *
+ * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
+ */
+type Ref = {
+  propertyName: string;
+  originalName: string;
+  path: KubbFile.Path;
+  pluginKey?: Plugin['key'];
+};
+type Refs = Record<string, Ref>;
+type OperationSchema = {
+  /**
+   * Converted name, contains already `PathParams`, `QueryParams`, ...
+   */
+  name: string;
+  schema: SchemaObject;
+  operation?: Operation;
+  /**
+   * OperationName in PascalCase, only being used in OperationGenerator
+   */
+  operationName: string;
+  description?: string;
+  statusCode?: number;
+  keys?: string[];
+  keysToOmit?: string[];
+  withData?: boolean;
+};
+type OperationSchemas = {
+  pathParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  queryParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  headerParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  request?: OperationSchema;
+  response: OperationSchema;
+  responses: Array<OperationSchema>;
+  statusCodes?: Array<OperationSchema>;
+  errors?: Array<OperationSchema>;
+};
+type ByTag = {
+  type: 'tag';
+  pattern: string | RegExp;
+};
+type ByOperationId = {
+  type: 'operationId';
+  pattern: string | RegExp;
+};
+type ByPath = {
+  type: 'path';
+  pattern: string | RegExp;
+};
+type ByMethod = {
+  type: 'method';
+  pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+  type: 'schemaName';
+  pattern: string | RegExp;
+};
+type ByContentType = {
+  type: 'contentType';
+  pattern: string | RegExp;
+};
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
+};
+//#endregion
+//#region ../plugin-oas/src/OperationGenerator.d.ts
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  exclude: Array<Exclude> | undefined;
+  include: Array<Include> | undefined;
+  override: Array<Override<TOptions>> | undefined;
+  contentType: contentType | undefined;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  UNSTABLE_NAMING?: true;
+};
+declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context$1<TPluginOptions['resolvedOptions'], TPluginOptions>> {
+  #private;
+  getOptions(operation: Operation, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']>;
+  getSchemas(operation: Operation, {
+    resolveName
+  }?: {
+    resolveName?: (name: string) => string;
+  }): OperationSchemas;
+  getOperations(): Promise<Array<{
+    path: string;
+    method: HttpMethod;
+    operation: Operation;
+  }>>;
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/SchemaMapper.d.ts
+type SchemaKeywordMapper = {
+  object: {
+    keyword: 'object';
+    args: {
+      properties: {
+        [x: string]: Schema[];
+      };
+      additionalProperties: Schema[];
+      patternProperties?: Record<string, Schema[]>;
+      strict?: boolean;
+    };
+  };
+  url: {
+    keyword: 'url';
+  };
+  readOnly: {
+    keyword: 'readOnly';
+  };
+  writeOnly: {
+    keyword: 'writeOnly';
+  };
+  uuid: {
+    keyword: 'uuid';
+  };
+  email: {
+    keyword: 'email';
+  };
+  firstName: {
+    keyword: 'firstName';
+  };
+  lastName: {
+    keyword: 'lastName';
+  };
+  phone: {
+    keyword: 'phone';
+  };
+  password: {
+    keyword: 'password';
+  };
+  date: {
+    keyword: 'date';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  time: {
+    keyword: 'time';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  datetime: {
+    keyword: 'datetime';
+    args: {
+      offset?: boolean;
+      local?: boolean;
+    };
+  };
+  tuple: {
+    keyword: 'tuple';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      rest?: Schema;
+    };
+  };
+  array: {
+    keyword: 'array';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      unique?: boolean;
+    };
+  };
+  enum: {
+    keyword: 'enum';
+    args: {
+      name: string;
+      typeName: string;
+      asConst: boolean;
+      items: Array<{
+        name: string | number;
+        format: 'string' | 'number' | 'boolean';
+        value?: string | number | boolean;
+      }>;
+    };
+  };
+  and: {
+    keyword: 'and';
+    args: Schema[];
+  };
+  const: {
+    keyword: 'const';
+    args: {
+      name: string | number;
+      format: 'string' | 'number' | 'boolean';
+      value?: string | number | boolean;
+    };
+  };
+  union: {
+    keyword: 'union';
+    args: Schema[];
+  };
+  ref: {
+    keyword: 'ref';
+    args: {
+      name: string;
+      $ref: string;
+      /**
+       * Full qualified path.
+       */
+      path: KubbFile.Path;
+      /**
+       * When true `File.Import` is used.
+       * When false a reference is used inside the current file.
+       */
+      isImportable: boolean;
+    };
+  };
+  matches: {
+    keyword: 'matches';
+    args?: string;
+  };
+  boolean: {
+    keyword: 'boolean';
+  };
+  default: {
+    keyword: 'default';
+    args: string | number | boolean;
+  };
+  string: {
+    keyword: 'string';
+  };
+  integer: {
+    keyword: 'integer';
+  };
+  number: {
+    keyword: 'number';
+  };
+  max: {
+    keyword: 'max';
+    args: number;
+  };
+  min: {
+    keyword: 'min';
+    args: number;
+  };
+  exclusiveMaximum: {
+    keyword: 'exclusiveMaximum';
+    args: number;
+  };
+  exclusiveMinimum: {
+    keyword: 'exclusiveMinimum';
+    args: number;
+  };
+  describe: {
+    keyword: 'describe';
+    args: string;
+  };
+  example: {
+    keyword: 'example';
+    args: string;
+  };
+  deprecated: {
+    keyword: 'deprecated';
+  };
+  optional: {
+    keyword: 'optional';
+  };
+  undefined: {
+    keyword: 'undefined';
+  };
+  nullish: {
+    keyword: 'nullish';
+  };
+  nullable: {
+    keyword: 'nullable';
+  };
+  null: {
+    keyword: 'null';
+  };
+  any: {
+    keyword: 'any';
+  };
+  unknown: {
+    keyword: 'unknown';
+  };
+  void: {
+    keyword: 'void';
+  };
+  blob: {
+    keyword: 'blob';
+  };
+  schema: {
+    keyword: 'schema';
+    args: {
+      type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+      format?: string;
+    };
+  };
+  name: {
+    keyword: 'name';
+    args: string;
+  };
+  catchall: {
+    keyword: 'catchall';
+  };
+  interface: {
+    keyword: 'interface';
+  };
+};
+type Schema = {
+  keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+//#endregion
+//#region ../plugin-oas/src/SchemaGenerator.d.ts
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  include?: Array<'schemas' | 'responses' | 'requestBodies'>;
+  override: Array<Override<TOptions>> | undefined;
+  contentType?: contentType;
+  output?: string;
+};
+type SchemaGeneratorOptions = {
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  unknownType: 'any' | 'unknown' | 'void';
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral';
+  enumSuffix?: string;
+  /**
+   * @deprecated Will be removed in v5. Use `collisionDetection: true` instead to prevent enum name collisions.
+   * When `collisionDetection` is enabled, the rootName-based approach eliminates the need for numeric suffixes.
+   * @internal
+   */
+  usedEnumNames?: Record<string, number>;
+  mapper?: Record<string, string>;
+  typed?: boolean;
+  transformers: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    /**
+     * Receive schema and name(propertyName) and return FakerMeta array
+     * TODO TODO add docs
+     * @beta
+     */
+    schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Array<Schema> | undefined;
+  };
+};
+type SchemaProps$1 = {
+  schema: SchemaObject | null;
+  name: string | null;
+  parentName: string | null;
+  rootName?: string | null;
+};
+declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
+  #private;
+  refs: Refs;
+  /**
+   * Creates a type node from a given schema.
+   * Delegates to getBaseTypeFromSchema internally and
+   * optionally adds a union with null.
+   */
+  parse(props: SchemaProps$1): Schema[];
+  static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
+  static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+  static combineObjects(tree: Schema[] | undefined): Schema[];
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/generators/createGenerator.d.ts
+type CoreGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
+};
+//#endregion
+//#region ../plugin-oas/src/generators/types.d.ts
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operations: Array<Operation>;
+};
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operation: Operation;
+};
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  schema: {
+    name: string;
+    tree: Array<Schema>;
+    value: SchemaObject;
+  };
+};
+type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
+//#endregion
+//#region ../plugin-oas/src/generators/createReactGenerator.d.ts
+type ReactGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  Operations: (props: OperationsProps<TOptions>) => FabricReactNode;
+  Operation: (props: OperationProps<TOptions>) => FabricReactNode;
+  Schema: (props: SchemaProps<TOptions>) => FabricReactNode;
+};
+//#endregion
 //#region src/generators/customHookOptionsFileGenerator.d.ts
 declare const customHookOptionsFileGenerator: ReactGenerator<PluginReactQuery>;
 //#endregion

package/dist/generators.js

@@ -1,3 +1,3 @@
-import { a as infiniteQueryGenerator, i as mutationGenerator, n as suspenseInfiniteQueryGenerator, o as hookOptionsGenerator, r as queryGenerator, s as customHookOptionsFileGenerator, t as suspenseQueryGenerator } from "./generators-DLX0cp80.js";
+import { a as infiniteQueryGenerator, i as mutationGenerator, n as suspenseInfiniteQueryGenerator, o as hookOptionsGenerator, r as queryGenerator, s as customHookOptionsFileGenerator, t as suspenseQueryGenerator } from "./generators-DTkvanZK.js";
 
 export { customHookOptionsFileGenerator, hookOptionsGenerator, infiniteQueryGenerator, mutationGenerator, queryGenerator, suspenseInfiniteQueryGenerator, suspenseQueryGenerator };

package/dist/index.cjs

@@ -1,5 +1,5 @@
 const require_components = require('./components-B6Ze18_y.cjs');
-const require_generators = require('./generators-BNYyHlZa.cjs');
+const require_generators = require('./generators-DtDEbt56.cjs');
 let node_path = require("node:path");
 node_path = require_components.__toESM(node_path);
 let _kubb_core = require("@kubb/core");

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { c as __name, n as Options, r as PluginReactQuery } from "./types-Fb-3R-ua.cjs";
+import { a as __name, n as Options, r as PluginReactQuery } from "./types-CgOcKVIt.cjs";
 import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { n as Options, r as PluginReactQuery } from "./types-CdpInNzi.js";
+import { n as Options, r as PluginReactQuery } from "./types-DoN-nl4J.js";
 import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts

package/dist/index.js

@@ -1,6 +1,6 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
 import { d as QueryKey, s as MutationKey } from "./components-Bz8jAFux.js";
-import { a as infiniteQueryGenerator, i as mutationGenerator, n as suspenseInfiniteQueryGenerator, o as hookOptionsGenerator, r as queryGenerator, s as customHookOptionsFileGenerator, t as suspenseQueryGenerator } from "./generators-DLX0cp80.js";
+import { a as infiniteQueryGenerator, i as mutationGenerator, n as suspenseInfiniteQueryGenerator, o as hookOptionsGenerator, r as queryGenerator, s as customHookOptionsFileGenerator, t as suspenseQueryGenerator } from "./generators-DTkvanZK.js";
 import path from "node:path";
 import { definePlugin, getBarrelFiles, getMode } from "@kubb/core";
 import { camelCase, pascalCase } from "@kubb/core/transformers";

package/dist/types-CgOcKVIt.d.cts

@@ -0,0 +1,204 @@
+import { HttpMethod, Oas, Operation, contentType } from "@kubb/oas";
+import { Exclude, Include, OperationSchemas, Override, ResolvePathOptions } from "@kubb/plugin-oas";
+import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
+import { PluginClient } from "@kubb/plugin-client";
+import { Generator } from "@kubb/plugin-oas/generators";
+
+//#region rolldown:runtime
+//#endregion
+//#region src/types.d.ts
+type TransformerProps = {
+  operation: Operation;
+  schemas: OperationSchemas;
+  casing: 'camelcase' | undefined;
+};
+type Transformer = (props: TransformerProps) => unknown[];
+type Suspense = object;
+/**
+ * Customize the queryKey
+ */
+type QueryKey = Transformer;
+/**
+ * Customize the mutationKey
+ */
+type MutationKey = Transformer;
+type Query = {
+  /**
+   * Define which HttpMethods can be used for queries
+   * @default ['get']
+   */
+  methods: Array<HttpMethod>;
+  /**
+   * Path to the useQuery hook for useQuery functionality.
+   * Used as `import { useQuery } from '${importPath}'`.
+   * Accepts relative and absolute paths.
+   * Path is used as-is; relative paths are based on the generated file location.
+   * @default '@tanstack/react-query'
+   */
+  importPath?: string;
+};
+type Mutation = {
+  /**
+   * Define which HttpMethods can be used for mutations
+   * @default ['post', 'put', 'delete']
+   */
+  methods: Array<HttpMethod>;
+  /**
+   * Path to the useQuery hook for useQuery functionality.
+   * Used as `import { useQuery } from '${importPath}'`.
+   * Accepts relative and absolute paths.
+   * Path is used as-is; relative paths are based on the generated file location.
+   * @default '@tanstack/react-query'
+   */
+  importPath?: string;
+};
+type Infinite = {
+  /**
+   * Specify the params key used for `pageParam`.
+   * @default 'id'
+   */
+  queryParam: string;
+  /**
+   * Which field of the data is used, set it to undefined when no cursor is known.
+   * @deprecated Use `nextParam` and `previousParam` instead for more flexible pagination handling.
+   */
+  cursorParam?: string | undefined;
+  /**
+   * Which field of the data is used to get the cursor for the next page.
+   * Supports dot notation (e.g. 'pagination.next.id') or array path (e.g. ['pagination', 'next', 'id']) to access nested fields.
+   */
+  nextParam?: string | string[] | undefined;
+  /**
+   * Which field of the data is used to get the cursor for the previous page.
+   * Supports dot notation (e.g. 'pagination.prev.id') or array path (e.g. ['pagination', 'prev', 'id']) to access nested fields.
+   */
+  previousParam?: string | string[] | undefined;
+  /**
+   * The initial value, the value of the first page.
+   * @default 0
+   */
+  initialPageParam: unknown;
+};
+type CustomOptions = {
+  /**
+   * Path to the hook that is used to customize the hook options.
+   * It used as `import ${customOptions.name} from '${customOptions.importPath}'`.
+   * It allows both relative and absolute paths but be aware that we will not change the path.
+   */
+  importPath: string;
+  /**
+   * Name of the exported hook that is used to customize the hook options.
+   * It used as `import ${customOptions.name} from '${customOptions.importPath}'`.
+   * @default 'useCustomHookOptions'
+   */
+  name?: string;
+};
+type Options = {
+  /**
+   * Specify the export location for the files and define the behavior of the output
+   * @default { path: 'hooks', barrelType: 'named' }
+   */
+  output?: Output<Oas>;
+  /**
+   * Define which contentType should be used.
+   * By default, the first JSON valid mediaType is used
+   */
+  contentType?: contentType;
+  /**
+   * Group the @tanstack/query hooks based on the provided name.
+   */
+  group?: Group;
+  client?: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>;
+  /**
+   * 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>>;
+  /**
+   * How to style your params, by default no casing is applied
+   * - 'camelcase' uses camelcase for the params names
+   */
+  paramsCasing?: 'camelcase';
+  /**
+   * How to pass your params.
+   * - 'object' returns the params and pathParams as an object.
+   * - 'inline' returns the params as comma separated params.
+   * @default 'inline'
+   */
+  paramsType?: 'object' | 'inline';
+  /**
+   * How to pass your pathParams.
+   * - 'object' returns the pathParams as an object.
+   * - 'inline': returns the pathParams as comma separated params.
+   * @default 'inline'
+   */
+  pathParamsType?: PluginClient['options']['pathParamsType'];
+  /**
+   * When set, an infiniteQuery hooks is added.
+   */
+  infinite?: Partial<Infinite> | false;
+  /**
+   * When set, a suspenseQuery hooks is added.
+   */
+  suspense?: Partial<Suspense> | false;
+  queryKey?: QueryKey;
+  /**
+   * Override some useQuery behaviors.
+   */
+  query?: Partial<Query> | false;
+  mutationKey?: MutationKey;
+  /**
+   * Override some useMutation behaviors.
+   */
+  mutation?: Partial<Mutation> | false;
+  /**
+   * When set, a custom hook is used to customize the options of the generated hooks.
+   * It will also generate a `HookOptions` type that can be used to type the custom options of each hook for type-safety.
+   */
+  customOptions?: CustomOptions;
+  /**
+   * Which parser should be used before returning the data to `@tanstack/query`.
+   * `'zod'` uses `@kubb/plugin-zod` to parse the data.
+   */
+  parser?: PluginClient['options']['parser'];
+  transformers?: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+  };
+  /**
+   * Define some generators next to the react-query generators
+   */
+  generators?: Array<Generator<PluginReactQuery>>;
+};
+type ResolvedOptions = {
+  output: Output<Oas>;
+  group: Options['group'];
+  client: NonNullable<PluginReactQuery['options']['client']>;
+  parser: Required<NonNullable<Options['parser']>>;
+  pathParamsType: NonNullable<Options['pathParamsType']>;
+  paramsCasing: Options['paramsCasing'];
+  paramsType: NonNullable<Options['paramsType']>;
+  /**
+   * Only used of infinite
+   */
+  infinite: NonNullable<Infinite> | false;
+  suspense: Suspense | false;
+  queryKey: QueryKey | undefined;
+  query: NonNullable<Required<Query>> | false;
+  mutationKey: MutationKey | undefined;
+  mutation: NonNullable<Required<Mutation>> | false;
+  customOptions: NonNullable<Required<CustomOptions>> | undefined;
+};
+type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options, ResolvedOptions, never, ResolvePathOptions>;
+//#endregion
+export { __name as a, Transformer as i, Options as n, PluginReactQuery as r, Infinite as t };
+//# sourceMappingURL=types-CgOcKVIt.d.cts.map