@kubb/plugin-react-query 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/chunk-7ZODZVKP.cjs

@@ -0,0 +1,1427 @@
+'use strict';
+
+var transformers2 = require('@kubb/core/transformers');
+var utils = require('@kubb/core/utils');
+var hooks = require('@kubb/plugin-oas/hooks');
+var utils$1 = require('@kubb/plugin-oas/utils');
+var react = require('@kubb/react');
+var pluginTs = require('@kubb/plugin-ts');
+var jsxRuntime = require('@kubb/react/jsx-runtime');
+var oas = require('@kubb/oas');
+var core = require('@kubb/core');
+var pluginZod = require('@kubb/plugin-zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var transformers2__default = /*#__PURE__*/_interopDefault(transformers2);
+
+// src/components/Mutation.tsx
+function SchemaType() {
+  const {
+    plugin: {
+      options: { dataReturnType }
+    }
+  } = react.useApp();
+  const { getSchemas, getName } = hooks.useOperationManager();
+  const operation = hooks.useOperation();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+  const [TData, TError, TRequest, TPathParams, TQueryParams, THeaderParams, TResponse] = [
+    schemas.response.name,
+    schemas.errors?.map((item) => item.name).join(" | ") || "never",
+    schemas.request?.name || "never",
+    schemas.pathParams?.name || "never",
+    schemas.queryParams?.name || "never",
+    schemas.headerParams?.name || "never",
+    schemas.response.name
+  ];
+  const factoryName = getName(operation, { type: "type" });
+  const clientType = `${factoryName}Client`;
+  const isFormData = operation.getContentType() === "multipart/form-data";
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name: clientType, isTypeOnly: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Type, { name: clientType, children: `typeof client<${TResponse}, ${TError}, ${isFormData ? "FormData" : TRequest}>` }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name: factoryName, isTypeOnly: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Type, { name: factoryName, children: `
+        {
+          data: ${TData}
+          error: ${TError}
+          request: ${isFormData ? "FormData" : TRequest}
+          pathParams: ${TPathParams}
+          queryParams: ${TQueryParams}
+          headerParams: ${THeaderParams}
+          response: ${dataReturnType === "data" ? TData : `Awaited<ReturnType<${clientType}>>`}
+          client: {
+            parameters: Partial<Parameters<${clientType}>[0]>
+            return: Awaited<ReturnType<${clientType}>>
+          }
+        }
+        ` }) })
+  ] });
+}
+function Template({ name, params, mutateParams, JSDoc, client, hook, dataReturnType }) {
+  const isFormData = client.contentType === "multipart/form-data";
+  const headers = [
+    client.contentType !== "application/json" ? `'Content-Type': '${client.contentType}'` : void 0,
+    client.withHeaders ? "...headers" : void 0
+  ].filter(Boolean).join(", ");
+  const clientOptions = [
+    `method: "${client.method}"`,
+    `url: ${client.path.template}`,
+    client.withQueryParams ? "params" : void 0,
+    client.withData && !isFormData ? "data" : void 0,
+    client.withData && isFormData ? "data: formData" : void 0,
+    headers.length ? `headers: { ${headers}, ...clientOptions.headers }` : void 0,
+    "...clientOptions"
+  ].filter(Boolean);
+  const resolvedClientOptions = `${transformers2__default.default.createIndent(4)}${clientOptions.join(`,
+${transformers2__default.default.createIndent(4)}`)}`;
+  const formData = isFormData ? `
+   const formData = new FormData()
+   if(data) {
+    Object.keys(data).forEach((key) => {
+      const value = data[key];
+      if (typeof key === "string" && (typeof value === "string" || value instanceof Blob)) {
+        formData.append(key, value);
+      }
+    })
+   }
+  ` : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { export: true, name, params, JSDoc, children: `
+         const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
+
+         return ${hook.name}({
+           mutationFn: async(${mutateParams}) => {
+             ${hook.children || ""}
+             ${formData || ""}
+             const res = await client<${client.generics}>({
+              ${resolvedClientOptions}
+             })
+
+             return ${dataReturnType === "data" ? "res.data" : "res"}
+           },
+           ...mutationOptions
+         })` }) });
+}
+function RootTemplate({ children }) {
+  const {
+    plugin: {
+      options: {
+        client: { importPath },
+        mutate
+      }
+    }
+  } = react.useApp();
+  const { getSchemas, getFile } = hooks.useOperationManager();
+  const operation = hooks.useOperation();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+  const file = getFile(operation);
+  const fileType = getFile(operation, { pluginKey: [pluginTs.pluginTsName] });
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: "client", path: importPath }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["ResponseConfig"], path: importPath, isTypeOnly: true }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.File.Import,
+      {
+        name: [
+          schemas.request?.name,
+          schemas.response.name,
+          schemas.pathParams?.name,
+          schemas.queryParams?.name,
+          schemas.headerParams?.name,
+          ...schemas.errors?.map((error) => error.name) || []
+        ].filter(Boolean),
+        root: file.path,
+        path: fileType.path,
+        isTypeOnly: true
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.File.Import,
+      {
+        name: ["UseMutationOptions", "UseMutationResult"],
+        path: typeof mutate !== "boolean" && mutate.importPath ? mutate.importPath : "@tanstack/react-query",
+        isTypeOnly: true
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["useMutation"], path: typeof mutate !== "boolean" && mutate.importPath ? mutate.importPath : "@tanstack/react-query" }),
+    children
+  ] });
+}
+var defaultTemplates = { default: Template, root: RootTemplate };
+function Mutation({ Template: Template6 = defaultTemplates.default }) {
+  const {
+    plugin: {
+      options: { dataReturnType, mutate }
+    }
+  } = react.useApp();
+  const operation = hooks.useOperation();
+  const { getSchemas, getName } = hooks.useOperationManager();
+  const name = getName(operation, { type: "function" });
+  const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+  const contentType = operation.getContentType();
+  const params = new utils.FunctionParams();
+  const mutateParams = new utils.FunctionParams();
+  const factoryName = getName(operation, { type: "type" });
+  const requestType = mutate && mutate.variablesType === "mutate" ? utils.FunctionParams.toObject([
+    ...utils$1.getASTParams(schemas.pathParams, { typed: true }),
+    {
+      name: "params",
+      type: `${factoryName}['queryParams']`,
+      enabled: !!schemas.queryParams?.name,
+      required: oas.isRequired(schemas.queryParams?.schema)
+    },
+    {
+      name: "headers",
+      type: `${factoryName}['headerParams']`,
+      enabled: !!schemas.headerParams?.name,
+      required: oas.isRequired(schemas.headerParams?.schema)
+    },
+    {
+      name: "data",
+      type: `${factoryName}['request']`,
+      enabled: !!schemas.request?.name,
+      required: oas.isRequired(schemas.request?.schema)
+    }
+  ])?.type : schemas.request?.name ? `${factoryName}['request']` : "never";
+  const client = {
+    method: operation.method,
+    path: new utils.URLPath(operation.path),
+    generics: [`${factoryName}["data"]`, `${factoryName}["error"]`, requestType ? `${factoryName}["request"]` : "void"].join(", "),
+    withQueryParams: !!schemas.queryParams?.name,
+    withData: !!schemas.request?.name,
+    withPathParams: !!schemas.pathParams?.name,
+    withHeaders: !!schemas.headerParams?.name,
+    contentType
+  };
+  const hook = {
+    name: "useMutation",
+    generics: [`${factoryName}['response']`, `${factoryName}["error"]`, requestType ? `${requestType}` : "void"].join(", ")
+  };
+  const resultGenerics = [
+    `${factoryName}["response"]`,
+    `${factoryName}["error"]`,
+    mutate && mutate?.variablesType === "mutate" ? requestType : `${factoryName}["request"]`
+  ];
+  if (mutate && mutate?.variablesType === "mutate") {
+    params.add([
+      {
+        name: "options",
+        type: `{
+      mutation?: UseMutationOptions<${resultGenerics.join(", ")}>,
+      client?: ${factoryName}['client']['parameters']
+  }`,
+        default: "{}"
+      }
+    ]);
+    mutateParams.add([
+      [
+        ...utils$1.getASTParams(schemas.pathParams, { typed: false }),
+        {
+          name: "params",
+          enabled: client.withQueryParams,
+          required: oas.isRequired(schemas.queryParams?.schema)
+        },
+        {
+          name: "headers",
+          enabled: client.withHeaders,
+          required: oas.isRequired(schemas.headerParams?.schema)
+        },
+        {
+          name: "data",
+          enabled: !!schemas.request?.name,
+          required: oas.isRequired(schemas.request?.schema)
+        }
+      ]
+    ]);
+  } else {
+    params.add([
+      ...utils$1.getASTParams(schemas.pathParams, { typed: true }),
+      {
+        name: "params",
+        type: `${factoryName}['queryParams']`,
+        enabled: client.withQueryParams,
+        required: oas.isRequired(schemas.queryParams?.schema)
+      },
+      {
+        name: "headers",
+        type: `${factoryName}['headerParams']`,
+        enabled: client.withHeaders,
+        required: oas.isRequired(schemas.headerParams?.schema)
+      },
+      {
+        name: "options",
+        type: `{
+      mutation?: UseMutationOptions<${resultGenerics.join(", ")}>,
+      client?: ${factoryName}['client']['parameters']
+  }`,
+        default: "{}"
+      }
+    ]);
+    mutateParams.add([
+      {
+        name: "data",
+        enabled: !!schemas.request?.name,
+        required: oas.isRequired(schemas.request?.schema)
+      }
+    ]);
+  }
+  if (!mutate) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(
+    Template6,
+    {
+      name,
+      JSDoc: { comments: utils$1.getComments(operation) },
+      client,
+      hook,
+      params: params.toString(),
+      mutateParams: mutateParams.toString(),
+      dataReturnType
+    }
+  ) });
+}
+Mutation.File = function({ ...props }) {
+  const templates = { ...defaultTemplates, ...props.templates };
+  const Template6 = templates.default;
+  const RootTemplate2 = templates.root;
+  return /* @__PURE__ */ jsxRuntime.jsxs(RootTemplate2, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(SchemaType, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(Mutation, { Template: Template6 })
+  ] });
+};
+Mutation.templates = defaultTemplates;
+var reactQueryDepRegex = /@tanstack\/(react|solid|vue|svelte)-query/;
+function getImportNames() {
+  const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+  return {
+    mutation: {
+      react: {
+        path: "@tanstack/react-query",
+        hookName: "useMutation",
+        optionsType: "UseMutationOptions",
+        resultType: "UseMutationResult"
+      },
+      solid: {
+        path: "@tanstack/solid-query",
+        hookName: "createMutation",
+        optionsType: "CreateMutationOptions",
+        resultType: "CreateMutationResult"
+      },
+      svelte: {
+        path: "@tanstack/svelte-query",
+        hookName: "createMutation",
+        optionsType: "CreateMutationOptions",
+        resultType: "CreateMutationResult"
+      },
+      vue: {
+        path: "@tanstack/vue-query",
+        hookName: "useMutation",
+        optionsType: isV5 ? "UseMutationOptions" : "VueMutationObserverOptions",
+        resultType: "UseMutationReturnType"
+      }
+    },
+    query: {
+      react: {
+        path: "@tanstack/react-query",
+        hookName: "useQuery",
+        optionsType: isV5 ? "QueryObserverOptions" : "UseBaseQueryOptions",
+        resultType: "UseQueryResult"
+      },
+      solid: {
+        path: "@tanstack/solid-query",
+        hookName: "createQuery",
+        optionsType: "CreateBaseQueryOptions",
+        resultType: "CreateQueryResult"
+      },
+      svelte: {
+        path: "@tanstack/svelte-query",
+        hookName: "createQuery",
+        optionsType: "CreateBaseQueryOptions",
+        resultType: "CreateQueryResult"
+      },
+      vue: {
+        path: "@tanstack/vue-query",
+        hookName: "useQuery",
+        optionsType: isV5 ? "QueryObserverOptions" : "VueQueryObserverOptions",
+        resultType: isV5 ? "UseQueryReturnType" : "UseQueryReturnType"
+      }
+    },
+    queryInfinite: {
+      react: {
+        path: "@tanstack/react-query",
+        hookName: "useInfiniteQuery",
+        optionsType: isV5 ? "InfiniteQueryObserverOptions" : "UseInfiniteQueryOptions",
+        resultType: "UseInfiniteQueryResult"
+      },
+      solid: {
+        path: "@tanstack/solid-query",
+        hookName: "createInfiniteQuery",
+        optionsType: "CreateInfiniteQueryOptions",
+        resultType: "CreateInfiniteQueryResult"
+      },
+      svelte: {
+        path: "@tanstack/svelte-query",
+        hookName: "createInfiniteQuery",
+        optionsType: "CreateInfiniteQueryOptions",
+        resultType: "CreateInfiniteQueryResult"
+      },
+      vue: {
+        path: "@tanstack/vue-query",
+        hookName: "useInfiniteQuery",
+        optionsType: isV5 ? "UseInfiniteQueryOptions" : "VueInfiniteQueryObserverOptions",
+        resultType: isV5 ? "UseInfiniteQueryReturnType" : "VueInfiniteQueryObserverOptions"
+      }
+    },
+    querySuspense: {
+      react: {
+        path: "@tanstack/react-query",
+        hookName: "useSuspenseQuery",
+        optionsType: "UseSuspenseQueryOptions",
+        resultType: "UseSuspenseQueryResult"
+      }
+    }
+  };
+}
+function Template2({ path, hookPath = path, isInfinite, hookName, queryOptions, optionsType, resultType }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [optionsType, resultType], path, isTypeOnly: true }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [hookName], path: hookPath }),
+    queryOptions && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [queryOptions].filter(Boolean), path }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["QueryKey", "WithRequired", isInfinite ? "InfiniteData" : void 0].filter(Boolean), path, isTypeOnly: true })
+  ] });
+}
+var defaultTemplates2 = {
+  get react() {
+    return function({ context, hookPath, ...rest }) {
+      const importNames = getImportNames();
+      const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+      const { isInfinite, isSuspense } = context;
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Template2,
+        {
+          isInfinite,
+          ...isSuspense ? importNames.querySuspense.react : isInfinite ? importNames.queryInfinite.react : importNames.query.react,
+          queryOptions: isV5 ? isInfinite ? "infiniteQueryOptions" : "queryOptions" : void 0,
+          hookPath,
+          ...rest
+        }
+      );
+    };
+  },
+  get solid() {
+    return function({ context, hookPath, ...rest }) {
+      const importNames = getImportNames();
+      const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+      const { isInfinite } = context;
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Template2,
+        {
+          isInfinite,
+          ...isInfinite ? importNames.queryInfinite.solid : importNames.query.solid,
+          queryOptions: isV5 ? isInfinite ? "infiniteQueryOptions" : "queryOptions" : void 0,
+          hookPath,
+          ...rest
+        }
+      );
+    };
+  },
+  get svelte() {
+    return function({ context, hookPath, ...rest }) {
+      const importNames = getImportNames();
+      const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+      const { isInfinite } = context;
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Template2,
+        {
+          isInfinite,
+          ...isInfinite ? importNames.queryInfinite.svelte : importNames.query.svelte,
+          queryOptions: isV5 ? isInfinite ? "infiniteQueryOptions" : "queryOptions" : void 0,
+          hookPath,
+          ...rest
+        }
+      );
+    };
+  },
+  get vue() {
+    return function({ context, hookPath, ...rest }) {
+      const importNames = getImportNames();
+      const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+      const { isInfinite } = context;
+      const path = "@tanstack/vue-query";
+      return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        isV5 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Template2,
+            {
+              isInfinite,
+              ...isInfinite ? importNames.queryInfinite.vue : importNames.query.vue,
+              queryOptions: isInfinite ? "infiniteQueryOptions" : "queryOptions",
+              hookPath,
+              ...rest
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["QueryObserverOptions"], path, isTypeOnly: true })
+        ] }),
+        !isV5 && isInfinite && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [importNames.queryInfinite.vue.resultType], path, isTypeOnly: true }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [importNames.queryInfinite.vue.optionsType], path: "@tanstack/vue-query/build/lib/types", isTypeOnly: true }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [importNames.queryInfinite.vue.hookName], path })
+        ] }),
+        !isV5 && !isInfinite && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [importNames.query.vue.resultType], path, isTypeOnly: true }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [importNames.query.vue.optionsType], path: "@tanstack/vue-query/build/lib/types", isTypeOnly: true }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [importNames.query.vue.hookName], path })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["unref"], path: "vue" }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["MaybeRef"], path: "vue", isTypeOnly: true }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["QueryKey", "WithRequired"], path, isTypeOnly: true })
+      ] });
+    };
+  }
+};
+function QueryImports({ hookPath, isInfinite, isSuspense, Template: Template6 = defaultTemplates2.react }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Template6,
+    {
+      hookPath,
+      context: {
+        isInfinite,
+        isSuspense
+      }
+    }
+  );
+}
+QueryImports.templates = defaultTemplates2;
+function Template3({ name, typeName, params, generics, returnType, JSDoc, keys }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function.Arrow, { name, export: true, generics, params, returnType, singleLine: true, JSDoc, children: `[${keys}] as const` }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name: typeName, isExportable: true, isIndexable: true, isTypeOnly: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Type, { name: typeName, export: true, children: `ReturnType<typeof ${name}>` }) })
+  ] });
+}
+var defaultTemplates3 = {
+  get react() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template3, { ...props });
+    };
+  },
+  get solid() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template3, { ...props });
+    };
+  },
+  get svelte() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template3, { ...props });
+    };
+  },
+  get vue() {
+    return function({ context, ...rest }) {
+      const { factory } = context;
+      const {
+        plugin: {
+          options: { pathParamsType, query }
+        }
+      } = react.useApp();
+      const { getSchemas } = hooks.useOperationManager();
+      const operation = hooks.useOperation();
+      const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+      const path = new utils.URLPath(operation.path);
+      const params = new utils.FunctionParams();
+      const withQueryParams = !!schemas.queryParams?.name;
+      const withRequest = !!schemas.request?.name;
+      params.add([
+        ...pathParamsType === "object" ? [
+          utils$1.getASTParams(schemas.pathParams, {
+            typed: true,
+            override: (item) => ({
+              ...item,
+              type: `MaybeRef<${item.type}>`
+            })
+          })
+        ] : utils$1.getASTParams(schemas.pathParams, {
+          typed: true,
+          override: (item) => ({
+            ...item,
+            type: `MaybeRef<${item.type}>`
+          })
+        }),
+        {
+          name: "params",
+          type: `MaybeRef<${`${factory.name}["queryParams"]`}>`,
+          enabled: withQueryParams,
+          required: oas.isRequired(schemas.queryParams?.schema)
+        },
+        {
+          name: "request",
+          type: `MaybeRef<${`${factory.name}["request"]`}>`,
+          enabled: withRequest,
+          required: oas.isRequired(schemas.request?.schema)
+        }
+      ]);
+      const keys = [
+        path.toObject({
+          type: "path",
+          stringify: true,
+          replacer: (pathParam) => `unref(${pathParam})`
+        }),
+        withQueryParams ? "...(params ? [params] : [])" : void 0,
+        withRequest ? "...(request ? [request] : [])" : void 0
+      ].filter(Boolean);
+      return /* @__PURE__ */ jsxRuntime.jsx(Template3, { ...rest, params: params.toString(), keys: keys.join(", ") });
+    };
+  }
+};
+function QueryKey({ name, typeName, factory, keysFn, Template: Template6 = defaultTemplates3.react }) {
+  const {
+    plugin: {
+      options: { pathParamsType }
+    }
+  } = react.useApp();
+  const { getSchemas } = hooks.useOperationManager();
+  const operation = hooks.useOperation();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+  const path = new utils.URLPath(operation.path);
+  const params = new utils.FunctionParams();
+  const withQueryParams = !!schemas.queryParams?.name;
+  const withRequest = !!schemas.request?.name;
+  params.add([
+    ...pathParamsType === "object" ? [utils$1.getASTParams(schemas.pathParams, { typed: true })] : utils$1.getASTParams(schemas.pathParams, { typed: true }),
+    {
+      name: "params",
+      type: `${factory.name}["queryParams"]`,
+      enabled: withQueryParams,
+      required: oas.isRequired(schemas.queryParams?.schema)
+    },
+    {
+      name: "data",
+      type: `${factory.name}["request"]`,
+      enabled: withRequest,
+      required: oas.isRequired(schemas.request?.schema)
+    }
+  ]);
+  const keys = [
+    path.toObject({
+      type: "path",
+      stringify: true
+    }),
+    withQueryParams ? "...(params ? [params] : [])" : void 0,
+    withRequest ? "...(data ? [data] : [])" : void 0
+  ].filter(Boolean);
+  return /* @__PURE__ */ jsxRuntime.jsx(Template6, { typeName, name, params: params.toString(), keys: keysFn(keys).join(", "), context: { factory } });
+}
+QueryKey.templates = defaultTemplates3;
+function Template4({ name, params, generics, returnType, JSDoc, hook, client, infinite, dataReturnType, parser }) {
+  const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+  const isFormData = client.contentType === "multipart/form-data";
+  const headers = [
+    client.contentType !== "application/json" ? `'Content-Type': '${client.contentType}'` : void 0,
+    client.withHeaders ? "...headers" : void 0
+  ].filter(Boolean).join(", ");
+  const clientOptions = [
+    `method: "${client.method}"`,
+    `url: ${client.path.template}`,
+    client.withQueryParams && !infinite ? "params" : void 0,
+    client.withData && !isFormData ? "data" : void 0,
+    client.withData && isFormData ? "data: formData" : void 0,
+    headers.length ? `headers: { ${headers}, ...options.headers }` : void 0,
+    "...options",
+    client.withQueryParams && !!infinite ? `params: {
+      ...params,
+      ['${infinite.queryParam}']: pageParam,
+      ...(options.params || {}),
+    }` : void 0
+  ].filter(Boolean);
+  const queryOptions = [
+    isV5 && !!infinite ? `initialPageParam: ${infinite.initialPageParam}` : void 0,
+    isV5 && !!infinite && !!infinite.cursorParam ? `getNextPageParam: (lastPage) => lastPage['${infinite.cursorParam}']` : void 0,
+    isV5 && !!infinite && !!infinite.cursorParam ? `getPreviousPageParam: (firstPage) => firstPage['${infinite.cursorParam}']` : void 0,
+    isV5 && !!infinite && !infinite.cursorParam && dataReturnType === "full" ? "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1" : void 0,
+    isV5 && !!infinite && !infinite.cursorParam && dataReturnType === "data" ? "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1" : void 0,
+    isV5 && !!infinite && !infinite.cursorParam ? "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1" : void 0
+  ].filter(Boolean);
+  const resolvedClientOptions = `${transformers2__default.default.createIndent(4)}${clientOptions.join(`,
+${transformers2__default.default.createIndent(4)}`)}`;
+  const resolvedQueryOptions = `${transformers2__default.default.createIndent(4)}${queryOptions.join(`,
+${transformers2__default.default.createIndent(4)}`)}`;
+  let returnRes = parser ? `return ${parser}(res.data)` : "return res.data";
+  if (dataReturnType === "full") {
+    returnRes = parser ? `return {...res, data: ${parser}(res.data)}` : "return res";
+  }
+  const formData = isFormData ? `
+   const formData = new FormData()
+   if(data) {
+    Object.keys(data).forEach((key) => {
+      const value = data[key];
+      if (typeof key === "string" && (typeof value === "string" || value instanceof Blob)) {
+        formData.append(key, value);
+      }
+    })
+   }
+  ` : void 0;
+  if (infinite) {
+    if (isV5) {
+      return /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { name, export: true, params, JSDoc, children: `
+       const queryKey = ${hook.queryKey}
+
+       return infiniteQueryOptions({
+         queryKey,
+         queryFn: async ({ pageParam }) => {
+          ${hook.children || ""}
+          ${formData || ""}
+           const res = await client<${client.generics}>({
+            ${resolvedClientOptions}
+           })
+
+           ${returnRes}
+         },
+         ${resolvedQueryOptions}
+       })
+
+       ` }) });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { name, export: true, generics, returnType, params, JSDoc, children: `
+         const queryKey = ${hook.queryKey}
+
+         return {
+           queryKey,
+           queryFn: async ({ pageParam }) => {
+             ${hook.children || ""}
+             ${formData || ""}
+             const res = await client<${client.generics}>({
+              ${resolvedClientOptions}
+             })
+
+             ${returnRes}
+           },
+           ${resolvedQueryOptions}
+         }
+
+         ` }) });
+  }
+  if (isV5) {
+    return /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { name, export: true, params, JSDoc, children: `
+   const queryKey = ${hook.queryKey}
+
+   return queryOptions({
+     queryKey,
+     queryFn: async () => {
+       ${hook.children || ""}
+       ${formData || ""}
+       const res = await client<${client.generics}>({
+        ${resolvedClientOptions}
+       })
+
+       ${returnRes}
+     },
+     ${resolvedQueryOptions}
+   })
+
+   ` }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { name, export: true, generics, returnType, params, JSDoc, children: `
+       const queryKey = ${hook.queryKey}
+
+       return {
+         queryKey,
+         queryFn: async () => {
+           ${hook.children || ""}
+           ${formData || ""}
+           const res = await client<${client.generics}>({
+            ${resolvedClientOptions}
+           })
+
+           ${returnRes}
+         },
+         ${resolvedQueryOptions}
+       }
+
+       ` }) });
+}
+var defaultTemplates4 = {
+  get react() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template4, { ...props });
+    };
+  },
+  get solid() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template4, { ...props });
+    };
+  },
+  get svelte() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template4, { ...props });
+    };
+  },
+  get vue() {
+    return function({ client, context, ...rest }) {
+      const { factory, queryKey } = context;
+      const {
+        plugin: {
+          options: { pathParamsType }
+        }
+      } = react.useApp();
+      const { getSchemas } = hooks.useOperationManager();
+      const operation = hooks.useOperation();
+      const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+      const params = new utils.FunctionParams();
+      const queryKeyParams = new utils.FunctionParams();
+      params.add([
+        ...pathParamsType === "object" ? [
+          utils$1.getASTParams(schemas.pathParams, {
+            typed: true,
+            override: (item) => ({
+              ...item,
+              name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0,
+              type: `MaybeRef<${item.type}>`
+            })
+          })
+        ] : utils$1.getASTParams(schemas.pathParams, {
+          typed: true,
+          override: (item) => ({
+            ...item,
+            name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0,
+            type: `MaybeRef<${item.type}>`
+          })
+        }),
+        {
+          name: "refParams",
+          type: `MaybeRef<${schemas.queryParams?.name}>`,
+          enabled: client.withQueryParams,
+          required: oas.isRequired(schemas.queryParams?.schema)
+        },
+        {
+          name: "refHeaders",
+          type: `MaybeRef<${schemas.headerParams?.name}>`,
+          enabled: client.withHeaders,
+          required: oas.isRequired(schemas.headerParams?.schema)
+        },
+        {
+          name: "refData",
+          type: `MaybeRef<${schemas.request?.name}>`,
+          enabled: client.withData,
+          required: oas.isRequired(schemas.request?.schema)
+        },
+        {
+          name: "options",
+          type: `${factory.name}['client']['parameters']`,
+          default: "{}"
+        }
+      ]);
+      queryKeyParams.add([
+        ...pathParamsType === "object" ? [
+          utils$1.getASTParams(schemas.pathParams, {
+            override: (item) => ({
+              ...item,
+              name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0
+            })
+          })
+        ] : utils$1.getASTParams(schemas.pathParams, {
+          override: (item) => ({
+            ...item,
+            name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0
+          })
+        }),
+        {
+          name: "refParams",
+          enabled: client.withQueryParams,
+          required: oas.isRequired(schemas.queryParams?.schema)
+        },
+        {
+          name: "refData",
+          enabled: client.withData,
+          required: oas.isRequired(schemas.request?.schema)
+        }
+      ]);
+      const unrefs = params.items.filter((item) => item.enabled).map((item) => {
+        return item.name ? `const ${transformers2__default.default.camelCase(item.name.replace("ref", ""))} = unref(${item.name})` : void 0;
+      }).join("\n");
+      const hook = {
+        queryKey: `${queryKey}(${queryKeyParams.toString()})`,
+        children: unrefs
+      };
+      return /* @__PURE__ */ jsxRuntime.jsx(Template4, { ...rest, params: params.toString(), hook, client });
+    };
+  }
+};
+function QueryOptions({ factory, infinite, suspense, resultType, dataReturnType, Template: Template6 = defaultTemplates4.react }) {
+  const {
+    pluginManager,
+    plugin: {
+      key: pluginKey,
+      options: { parser, pathParamsType, queryOptions }
+    }
+  } = react.useApp();
+  const { getSchemas } = hooks.useOperationManager();
+  const operation = hooks.useOperation();
+  const contentType = operation.getContentType();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+  const zodSchemas = getSchemas(operation, { pluginKey: [pluginZod.pluginZodName], type: "function" });
+  const queryKey = pluginManager.resolveName({
+    name: [factory.name, infinite ? "Infinite" : void 0, suspense ? "Suspense" : void 0, "QueryKey"].filter(Boolean).join(""),
+    pluginKey
+  });
+  const queryOptionsName = pluginManager.resolveName({
+    name: [factory.name, infinite ? "Infinite" : void 0, suspense ? "Suspense" : void 0, "QueryOptions"].filter(Boolean).join(""),
+    pluginKey
+  });
+  const generics = new utils.FunctionParams();
+  const params = new utils.FunctionParams();
+  const queryKeyParams = new utils.FunctionParams();
+  const clientGenerics = [`${factory.name}['data']`, `${factory.name}['error']`];
+  const resultGenerics = suspense ? [`${factory.name}['response']`, `${factory.name}["error"]`, "TData"] : [`${factory.name}['response']`, `${factory.name}["error"]`, "TData", "TQueryData"];
+  const client = {
+    withQueryParams: !!schemas.queryParams?.name,
+    withData: !!schemas.request?.name,
+    withPathParams: !!schemas.pathParams?.name,
+    withHeaders: !!schemas.headerParams?.name,
+    method: operation.method,
+    path: new utils.URLPath(operation.path),
+    generics: clientGenerics.toString(),
+    contentType
+  };
+  generics.add([
+    { type: "TData", default: `${factory.name}["response"]` },
+    suspense ? void 0 : { type: "TQueryData", default: `${factory.name}["response"]` }
+  ]);
+  params.add([
+    ...pathParamsType === "object" ? [utils$1.getASTParams(schemas.pathParams, { typed: true })] : utils$1.getASTParams(schemas.pathParams, { typed: true }),
+    {
+      name: "params",
+      type: `${factory.name}['queryParams']`,
+      enabled: client.withQueryParams,
+      required: oas.isRequired(schemas.queryParams?.schema)
+    },
+    {
+      name: "headers",
+      type: `${factory.name}['headerParams']`,
+      enabled: client.withHeaders,
+      required: oas.isRequired(schemas.headerParams?.schema)
+    },
+    {
+      name: "data",
+      type: `${factory.name}['request']`,
+      enabled: client.withData,
+      required: oas.isRequired(schemas.request?.schema)
+    },
+    {
+      name: "options",
+      type: `${factory.name}['client']['parameters']`,
+      default: "{}"
+    }
+  ]);
+  queryKeyParams.add([
+    ...pathParamsType === "object" ? [utils$1.getASTParams(schemas.pathParams)] : utils$1.getASTParams(schemas.pathParams),
+    {
+      name: "params",
+      enabled: client.withQueryParams,
+      required: oas.isRequired(schemas.queryParams?.schema)
+    },
+    {
+      name: "data",
+      enabled: client.withData,
+      required: oas.isRequired(schemas.request?.schema)
+    }
+  ]);
+  const hook = {
+    queryKey: `${queryKey}(${queryKeyParams.toString()})`
+  };
+  if (!queryOptions) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Template6,
+    {
+      name: queryOptionsName,
+      params: params.toString(),
+      generics: generics.toString(),
+      returnType: `WithRequired<${resultType}<${resultGenerics.join(", ")}>, 'queryKey'>`,
+      client,
+      hook,
+      infinite,
+      dataReturnType,
+      parser: parser === "zod" ? `${zodSchemas.response.name}.parse` : void 0,
+      context: {
+        factory,
+        queryKey
+      }
+    }
+  );
+}
+QueryOptions.templates = defaultTemplates4;
+function Template5({ name, generics, returnType, params, JSDoc, hook, infinite }) {
+  const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+  const resolvedReturnType = `${returnType} & { queryKey: TQueryKey }`;
+  if (isV5) {
+    return /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { name, export: true, generics, returnType: resolvedReturnType, params, JSDoc, children: `
+         const { query: queryOptions, client: clientOptions = {} } = options ?? {}
+         const queryKey = queryOptions?.queryKey ?? ${hook.queryKey}
+
+         const query = ${hook.name}({
+          ...${hook.queryOptions} as unknown as ${infinite ? "InfiniteQueryObserverOptions" : "QueryObserverOptions"},
+          queryKey,
+          ...queryOptions as unknown as ${infinite ? 'Omit<InfiniteQueryObserverOptions, "queryKey">' : 'Omit<QueryObserverOptions, "queryKey">'}
+        }) as ${resolvedReturnType}
+
+        query.queryKey = queryKey as TQueryKey
+
+        return query
+
+         ` }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { name, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsxRuntime.jsx(react.Function, { name, export: true, generics, returnType: resolvedReturnType, params, JSDoc, children: `
+       const { query: queryOptions, client: clientOptions = {} } = options ?? {}
+       const queryKey = queryOptions?.queryKey ?? ${hook.queryKey}
+
+       const query = ${hook.name}<${hook.generics}>({
+        ...${hook.queryOptions},
+        queryKey,
+        ...queryOptions
+      }) as ${resolvedReturnType}
+
+      query.queryKey = queryKey as TQueryKey
+
+      return query
+
+       ` }) });
+}
+var defaultTemplates5 = {
+  get react() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template5, { ...props });
+    };
+  },
+  get solid() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template5, { ...props });
+    };
+  },
+  get svelte() {
+    return function(props) {
+      return /* @__PURE__ */ jsxRuntime.jsx(Template5, { ...props });
+    };
+  },
+  get vue() {
+    return function({ context, hook, ...rest }) {
+      const { factory, queryKey } = context;
+      const {
+        pluginManager,
+        plugin: {
+          key: pluginKey,
+          options: { pathParamsType }
+        }
+      } = react.useApp();
+      const operation = hooks.useOperation();
+      const { getSchemas } = hooks.useOperationManager();
+      const importNames = getImportNames();
+      const queryOptions = pluginManager.resolveName({
+        name: `${factory.name}QueryOptions`,
+        pluginKey
+      });
+      const hookName = rest.infinite ? importNames.queryInfinite.vue.hookName : importNames.query.vue.hookName;
+      const resultType = rest.infinite ? importNames.queryInfinite.vue.resultType : importNames.query.vue.resultType;
+      const optionsType = rest.infinite ? importNames.queryInfinite.vue.optionsType : importNames.query.vue.optionsType;
+      const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+      const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+      const params = new utils.FunctionParams();
+      const queryParams = new utils.FunctionParams();
+      const queryKeyParams = new utils.FunctionParams();
+      const client = {
+        withQueryParams: !!schemas.queryParams?.name,
+        withData: !!schemas.request?.name,
+        withPathParams: !!schemas.pathParams?.name,
+        withHeaders: !!schemas.headerParams?.name
+      };
+      const resultGenerics = ["TData", `${factory.name}['error']`];
+      const queryOptionsOverrideGenerics = [`${factory.name}['response']`, `${factory.name}['error']`, "TData", "TQueryKey"];
+      const queryOptionsGenerics = ["TData", "TQueryData"];
+      params.add([
+        ...pathParamsType === "object" ? [
+          utils$1.getASTParams(schemas.pathParams, {
+            typed: true,
+            override: (item) => ({
+              ...item,
+              name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0
+            })
+          })
+        ] : utils$1.getASTParams(schemas.pathParams, {
+          typed: true,
+          override: (item) => ({
+            ...item,
+            name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0
+          })
+        }),
+        {
+          name: "refParams",
+          type: `MaybeRef<${schemas.queryParams?.name}>`,
+          enabled: client.withQueryParams,
+          required: oas.isRequired(schemas.queryParams?.schema)
+        },
+        {
+          name: "refHeaders",
+          type: `MaybeRef<${schemas.headerParams?.name}>`,
+          enabled: client.withHeaders,
+          required: oas.isRequired(schemas.headerParams?.schema)
+        },
+        {
+          name: "refData",
+          type: `MaybeRef<${schemas.request?.name}>`,
+          enabled: client.withData,
+          required: oas.isRequired(schemas.request?.schema)
+        },
+        {
+          name: "options",
+          type: `{
+              query?: Partial<${optionsType}<${queryOptionsOverrideGenerics.join(", ")}>>,
+              client?: ${factory.name}['client']['parameters']
+          }`,
+          default: "{}"
+        }
+      ]);
+      queryParams.add([
+        ...utils$1.getASTParams(schemas.pathParams, {
+          typed: false,
+          override: (item) => ({
+            ...item,
+            name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0
+          })
+        }),
+        {
+          name: "refParams",
+          enabled: client.withQueryParams,
+          required: oas.isRequired(schemas.queryParams?.schema)
+        },
+        {
+          name: "refHeaders",
+          enabled: client.withHeaders,
+          required: oas.isRequired(schemas.headerParams?.schema)
+        },
+        {
+          name: "clientOptions",
+          required: false
+        }
+      ]);
+      queryKeyParams.add([
+        ...pathParamsType === "object" ? [
+          utils$1.getASTParams(schemas.pathParams, {
+            override: (item) => ({
+              ...item,
+              name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0
+            })
+          })
+        ] : utils$1.getASTParams(schemas.pathParams, {
+          override: (item) => ({
+            ...item,
+            name: item.name ? `ref${transformers2__default.default.pascalCase(item.name)}` : void 0
+          })
+        }),
+        {
+          name: "refParams",
+          enabled: client.withQueryParams,
+          required: oas.isRequired(schemas.queryParams?.schema)
+        },
+        {
+          name: "refData",
+          enabled: client.withData,
+          required: oas.isRequired(schemas.request?.schema)
+        }
+      ]);
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Template5,
+        {
+          ...rest,
+          params: params.toString(),
+          returnType: `${resultType}<${resultGenerics.join(", ")}>`,
+          hook: {
+            ...hook,
+            name: hookName,
+            queryOptions: isV5 ? `${queryOptions}(${queryParams.toString()})` : `${queryOptions}<${queryOptionsGenerics.join(", ")}>(${queryParams.toString()})`,
+            queryKey: `${queryKey}(${queryKeyParams.toString()})`
+          }
+        }
+      );
+    };
+  }
+};
+function Query({
+  factory,
+  optionsType,
+  hookName,
+  resultType,
+  Template: Template6 = defaultTemplates5.react,
+  QueryKeyTemplate = QueryKey.templates.react,
+  QueryOptionsTemplate = QueryOptions.templates.react,
+  ...props
+}) {
+  const {
+    pluginManager,
+    plugin: {
+      key: pluginKey,
+      options: { dataReturnType, pathParamsType }
+    }
+  } = react.useApp();
+  const operation = hooks.useOperation();
+  const { getSchemas, getName } = hooks.useOperationManager();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+  const name = getName(operation, { type: "function" });
+  const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+  const queryKey = pluginManager.resolveName({
+    name: [factory.name, props.infinite ? "Infinite" : void 0, props.suspense ? "Suspense" : void 0, "QueryKey"].filter(Boolean).join(""),
+    pluginKey
+  });
+  const queryKeyType = pluginManager.resolveName({
+    name: [factory.name, props.infinite ? "Infinite" : void 0, props.suspense ? "Suspense" : void 0, "QueryKey"].filter(Boolean).join(""),
+    type: "type",
+    pluginKey
+  });
+  const queryOptions = pluginManager.resolveName({
+    name: [factory.name, props.infinite ? "Infinite" : void 0, props.suspense ? "Suspense" : void 0, "QueryOptions"].filter(Boolean).join(""),
+    pluginKey
+  });
+  const generics = new utils.FunctionParams();
+  const params = new utils.FunctionParams();
+  const queryParams = new utils.FunctionParams();
+  const queryKeyParams = new utils.FunctionParams();
+  const client = {
+    method: operation.method,
+    path: new utils.URLPath(operation.path),
+    withQueryParams: !!schemas.queryParams?.name,
+    withData: !!schemas.request?.name,
+    withPathParams: !!schemas.pathParams?.name,
+    withHeaders: !!schemas.headerParams?.name
+  };
+  generics.add([
+    {
+      type: "TData",
+      default: props.infinite ? `InfiniteData<${factory.name}["response"]>` : `${factory.name}["response"]`
+    },
+    props.suspense ? void 0 : { type: "TQueryData", default: `${factory.name}["response"]` },
+    { type: "TQueryKey extends QueryKey", default: queryKeyType }
+  ]);
+  const resultGenerics = ["TData", `${factory.name}['error']`];
+  const queryOptionsOverrideGenerics = props.suspense ? [`${factory.name}['response']`, `${factory.name}['error']`, "TData", "TQueryKey"] : [`${factory.name}['response']`, `${factory.name}['error']`, "TData", "TQueryData", "TQueryKey"];
+  const queryOptionsGenerics = props.suspense ? ["TData"] : ["TData", "TQueryData"];
+  params.add([
+    ...pathParamsType === "object" ? [utils$1.getASTParams(schemas.pathParams, { typed: true })] : utils$1.getASTParams(schemas.pathParams, { typed: true }),
+    {
+      name: "params",
+      type: `${factory.name}['queryParams']`,
+      enabled: client.withQueryParams,
+      required: oas.isRequired(schemas.queryParams?.schema)
+    },
+    {
+      name: "headers",
+      type: `${factory.name}['headerParams']`,
+      enabled: client.withHeaders,
+      required: oas.isRequired(schemas.headerParams?.schema)
+    },
+    {
+      name: "data",
+      type: `${factory.name}['request']`,
+      enabled: client.withData,
+      required: oas.isRequired(schemas.request?.schema)
+    },
+    {
+      name: "options",
+      type: `{
+    query?: Partial<${optionsType}<${queryOptionsOverrideGenerics.join(", ")}>>,
+    client?: ${factory.name}['client']['parameters']
+}`,
+      default: "{}"
+    }
+  ]);
+  queryParams.add([
+    ...pathParamsType === "object" ? [utils$1.getASTParams(schemas.pathParams)] : utils$1.getASTParams(schemas.pathParams),
+    {
+      name: "params",
+      enabled: client.withQueryParams,
+      required: oas.isRequired(schemas.queryParams?.schema)
+    },
+    {
+      name: "headers",
+      enabled: client.withHeaders,
+      required: oas.isRequired(schemas.headerParams?.schema)
+    },
+    {
+      name: "data",
+      enabled: client.withData,
+      required: oas.isRequired(schemas.request?.schema)
+    },
+    {
+      name: "clientOptions",
+      required: false
+    }
+  ]);
+  queryKeyParams.add([
+    ...pathParamsType === "object" ? [utils$1.getASTParams(schemas.pathParams)] : utils$1.getASTParams(schemas.pathParams),
+    {
+      name: "params",
+      enabled: client.withQueryParams,
+      required: oas.isRequired(schemas.queryParams?.schema)
+    },
+    {
+      name: "data",
+      enabled: client.withData,
+      required: oas.isRequired(schemas.request?.schema)
+    }
+  ]);
+  const hook = {
+    name: hookName,
+    generics: [isV5 ? "any" : `${factory.name}['data']`, `${factory.name}['error']`, "TData", "any"].join(", "),
+    queryOptions: isV5 ? `${queryOptions}(${queryParams.toString()})` : `${queryOptions}<${queryOptionsGenerics.join(", ")}>(${queryParams.toString()})`,
+    queryKey: `${queryKey}(${queryKeyParams.toString()})`
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      QueryKey,
+      {
+        keysFn: props.query ? props.query.queryKey : (keys) => keys,
+        Template: QueryKeyTemplate,
+        factory,
+        name: queryKey,
+        typeName: queryKeyType
+      }
+    ),
+    props.queryOptions && /* @__PURE__ */ jsxRuntime.jsx(
+      QueryOptions,
+      {
+        Template: QueryOptionsTemplate,
+        factory,
+        resultType: optionsType,
+        dataReturnType,
+        infinite: props.infinite,
+        suspense: props.suspense
+      }
+    ),
+    props.query && /* @__PURE__ */ jsxRuntime.jsx(
+      Template6,
+      {
+        name: [name, props.infinite ? "Infinite" : void 0, props.suspense ? "Suspense" : void 0].filter(Boolean).join(""),
+        generics: generics.toString(),
+        JSDoc: { comments: utils$1.getComments(operation) },
+        params: params.toString(),
+        returnType: `${resultType}<${resultGenerics.join(", ")}>`,
+        hook,
+        infinite: props.infinite,
+        context: {
+          factory,
+          queryKey
+        }
+      }
+    )
+  ] });
+}
+Query.File = function({ templates }) {
+  const {
+    plugin: {
+      options: {
+        client: { importPath },
+        infinite,
+        suspense,
+        query,
+        queryOptions,
+        parser
+      }
+    }
+  } = react.useApp();
+  const { getSchemas, getFile, getName } = hooks.useOperationManager();
+  const operation = hooks.useOperation();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTs.pluginTsName], type: "type" });
+  const zodSchemas = getSchemas(operation, { pluginKey: [pluginZod.pluginZodName], type: "function" });
+  const file = getFile(operation);
+  const fileType = getFile(operation, { pluginKey: [pluginTs.pluginTsName] });
+  const fileZodSchemas = getFile(operation, {
+    pluginKey: [pluginZod.pluginZodName]
+  });
+  const factoryName = getName(operation, { type: "type" });
+  const importNames = getImportNames();
+  const isV5 = new core.PackageManager().isValidSync(reactQueryDepRegex, ">=5");
+  const Template6 = templates?.query["react"] || defaultTemplates5["react"];
+  const QueryOptionsTemplate = templates?.queryOptions["react"] || QueryOptions.templates["react"];
+  const QueryKeyTemplate = templates?.queryKey["react"] || QueryKey.templates["react"];
+  const Import = templates?.queryImports["react"] || QueryImports.templates["react"];
+  const factory = {
+    name: factoryName
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+    parser === "zod" && /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: [zodSchemas.response?.name], root: file.path, path: fileZodSchemas.path }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: "client", path: importPath }),
+    /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["ResponseConfig"], path: importPath, isTypeOnly: true }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.File.Import,
+      {
+        name: [
+          schemas.request?.name,
+          schemas.response.name,
+          schemas.pathParams?.name,
+          schemas.queryParams?.name,
+          schemas.headerParams?.name,
+          ...schemas.errors?.map((error) => error.name) || []
+        ].filter(Boolean),
+        root: file.path,
+        path: fileType.path,
+        isTypeOnly: true
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(QueryImports, { hookPath: typeof query !== "boolean" ? query.importPath : void 0, Template: Import, isInfinite: false, isSuspense: false }),
+    !!infinite && /* @__PURE__ */ jsxRuntime.jsx(QueryImports, { hookPath: typeof query !== "boolean" ? query.importPath : void 0, Template: Import, isInfinite: true, isSuspense: false }),
+    !!suspense && isV5 && /* @__PURE__ */ jsxRuntime.jsx(QueryImports, { hookPath: typeof query !== "boolean" ? query.importPath : void 0, Template: Import, isInfinite: false, isSuspense: true }),
+    /* @__PURE__ */ jsxRuntime.jsx(SchemaType, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Query,
+      {
+        factory,
+        Template: Template6,
+        QueryKeyTemplate,
+        QueryOptionsTemplate,
+        infinite: false,
+        suspense: false,
+        query,
+        queryOptions,
+        hookName: importNames.query["react"].hookName,
+        resultType: importNames.query["react"].resultType,
+        optionsType: importNames.query["react"].optionsType
+      }
+    ),
+    !!infinite && /* @__PURE__ */ jsxRuntime.jsx(
+      Query,
+      {
+        factory,
+        Template: Template6,
+        QueryKeyTemplate,
+        QueryOptionsTemplate,
+        infinite,
+        suspense: false,
+        query,
+        queryOptions,
+        hookName: importNames.queryInfinite["react"].hookName,
+        resultType: importNames.queryInfinite["react"].resultType,
+        optionsType: importNames.queryInfinite["react"].optionsType
+      }
+    ),
+    !!suspense && isV5 && /* @__PURE__ */ jsxRuntime.jsx(
+      Query,
+      {
+        factory,
+        Template: Template6,
+        QueryKeyTemplate,
+        QueryOptionsTemplate,
+        infinite: false,
+        suspense,
+        query,
+        queryOptions,
+        hookName: importNames.querySuspense["react"].hookName,
+        resultType: importNames.querySuspense["react"].resultType,
+        optionsType: importNames.querySuspense["react"].optionsType
+      }
+    )
+  ] });
+};
+Query.templates = defaultTemplates5;
+
+exports.Mutation = Mutation;
+exports.Query = Query;
+exports.QueryImports = QueryImports;
+exports.QueryKey = QueryKey;
+exports.QueryOptions = QueryOptions;
+//# sourceMappingURL=chunk-7ZODZVKP.cjs.map
+//# sourceMappingURL=chunk-7ZODZVKP.cjs.map