@kubb/plugin-swr 3.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Stijn Van Hulle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+<div align="center">
+
+<!-- <img src="assets/logo.png" alt="logo" width="200" height="auto" /> -->
+<h1>@kubb/plugin-swr</h1>
+
+<p>
+   Swagger integration for SWR to generate all the different SWR hooks based on an OpenAPI specification.
+  </p>
+  <img src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/banner.png" alt="logo"  height="auto" />
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Coverage][coverage-src]][coverage-href]
+[![License][license-src]][license-href]
+
+<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+<!-- ALL-CONTRIBUTORS-BADGE:END -->
+</p>
+
+<h4>
+    <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/alpha/examples/typescript" target="_blank">View Demo</a>
+    <span> · </span>
+      <a href="https://kubb.dev/" target="_blank">Documentation</a>
+    <span> · </span>
+      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
+    <span> · </span>
+      <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Request Feature</a>
+  </h4>
+</div>
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@kubb/plugin-swr?flat&colorA=18181B&colorB=f58517
+[npm-version-href]: https://npmjs.com/package/@kubb/plugin-swr
+[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/plugin-swr?flat&colorA=18181B&colorB=f58517
+[npm-downloads-href]: https://npmjs.com/package/@kubb/plugin-swr
+[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
+[license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
+[build-src]: https://img.shields.io/github/actions/workflow/status/kubb-labs/kubb/ci.yaml?style=flat&colorA=18181B&colorB=f58517
+[build-href]: https://www.npmjs.com/package/@kubb/plugin-swr
+[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/plugin-swr?style=flat&colorA=18181B&colorB=f58517
+[minified-href]: https://www.npmjs.com/package/@kubb/plugin-swr
+[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
+[coverage-href]: https://www.npmjs.com/package/@kubb/plugin-swr

package/dist/chunk-ECJ346AA.js

@@ -0,0 +1,542 @@
+// src/components/Mutation.tsx
+import transformers from "@kubb/core/transformers";
+import { FunctionParams, URLPath } from "@kubb/core/utils";
+import { Parser, File, Function, useApp as useApp2 } from "@kubb/react";
+import { pluginTsName as pluginTsName2 } from "@kubb/plugin-ts";
+import { useOperation as useOperation2, useOperationManager as useOperationManager2 } from "@kubb/plugin-oas/hooks";
+import { getASTParams, getComments } from "@kubb/plugin-oas/utils";
+
+// src/components/SchemaType.tsx
+import { Type, useApp } from "@kubb/react";
+import { useOperation, useOperationManager } from "@kubb/plugin-oas/hooks";
+import { pluginTsName } from "@kubb/plugin-ts";
+import { Fragment, jsx, jsxs } from "@kubb/react/jsx-runtime";
+function SchemaType({ factory }) {
+  const {
+    plugin: {
+      options: { dataReturnType }
+    }
+  } = useApp();
+  const { getSchemas } = useOperationManager();
+  const operation = useOperation();
+  const schemas = getSchemas(operation, { pluginKey: [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 clientType = `${factory.name}Client`;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Type, { name: clientType, children: `typeof client<${TResponse}, ${TError}, ${TRequest}>` }),
+    /* @__PURE__ */ jsx(Type, { name: factory.name, children: `
+        {
+          data: ${TData}
+          error: ${TError}
+          request: ${TRequest}
+          pathParams: ${TPathParams}
+          queryParams: ${TQueryParams}
+          headerParams: ${THeaderParams}
+          response: ${dataReturnType === "data" ? TData : `Awaited<ReturnType<${clientType}>>`}
+          client: {
+            parameters: Partial<Parameters<${clientType}>[0]>
+            return: Awaited<ReturnType<${clientType}>>
+          }
+        }
+        ` })
+  ] });
+}
+
+// src/components/Mutation.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
+function Template({ name, generics, returnType, params, JSDoc, client, hook, dataReturnType }) {
+  const clientOptions = [
+    `method: "${client.method}"`,
+    "url",
+    client.withQueryParams ? "params" : void 0,
+    client.withData ? "data" : void 0,
+    client.withHeaders ? "headers: { ...headers, ...clientOptions.headers }" : void 0,
+    "...clientOptions"
+  ].filter(Boolean);
+  const resolvedClientOptions = `${transformers.createIndent(4)}${clientOptions.join(`,
+${transformers.createIndent(4)}`)}`;
+  if (client.withQueryParams) {
+    return /* @__PURE__ */ jsx2(Function, { export: true, name, generics, returnType, params, JSDoc, children: `
+         const { mutation: mutationOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
+
+         const url = ${client.path.template} as const
+         return ${hook.name}<${hook.generics}>(
+          shouldFetch ? [url, params]: null,
+          async (_url${client.withData ? ", { arg: data }" : ""}) => {
+            const res = await client<${client.generics}>({
+              ${resolvedClientOptions}
+            })
+
+            return ${dataReturnType === "data" ? "res.data" : "res"}
+          },
+          mutationOptions
+        )
+      ` });
+  }
+  return /* @__PURE__ */ jsx2(Function, { export: true, name, generics, returnType, params, JSDoc, children: `
+       const { mutation: mutationOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
+
+       const url = ${client.path.template} as const
+       return ${hook.name}<${hook.generics}>(
+        shouldFetch ? url : null,
+        async (_url${client.withData ? ", { arg: data }" : ""}) => {
+          const res = await client<${client.generics}>({
+            ${resolvedClientOptions}
+          })
+
+          return ${dataReturnType === "data" ? "res.data" : "res"}
+        },
+        mutationOptions
+      )
+    ` });
+}
+var defaultTemplates = {
+  default: Template
+};
+function Mutation({ factory, Template: Template4 = defaultTemplates.default }) {
+  const {
+    plugin: {
+      options: { dataReturnType }
+    }
+  } = useApp2();
+  const { getSchemas, getName } = useOperationManager2();
+  const operation = useOperation2();
+  const name = getName(operation, { type: "function" });
+  const schemas = getSchemas(operation, { pluginKey: [pluginTsName2], type: "type" });
+  const params = new FunctionParams();
+  const client = {
+    method: operation.method,
+    path: new URLPath(operation.path),
+    generics: [`${factory.name}["data"]`, `${factory.name}["error"]`, schemas.request?.name ? `${factory.name}["request"]` : ""].filter(Boolean).join(", "),
+    withQueryParams: !!schemas.queryParams?.name,
+    withData: !!schemas.request?.name,
+    withPathParams: !!schemas.pathParams?.name,
+    withHeaders: !!schemas.headerParams?.name
+  };
+  const resultGenerics = [`${factory.name}["response"]`, `${factory.name}["error"]`];
+  params.add([
+    ...getASTParams(schemas.pathParams, { typed: true }),
+    {
+      name: "params",
+      type: `${factory.name}['queryParams']`,
+      enabled: client.withQueryParams,
+      required: false
+    },
+    {
+      name: "headers",
+      type: `${factory.name}['headerParams']`,
+      enabled: client.withHeaders,
+      required: false
+    },
+    {
+      name: "options",
+      required: false,
+      type: `{
+        mutation?: SWRMutationConfiguration<${resultGenerics.join(", ")}>,
+        client?: ${factory.name}['client']['parameters'],
+        shouldFetch?: boolean,
+      }`,
+      default: "{}"
+    }
+  ]);
+  const hook = {
+    name: "useSWRMutation",
+    generics: [...resultGenerics, client.withQueryParams ? "[typeof url, typeof params] | null" : "typeof url | null"].join(", ")
+  };
+  return /* @__PURE__ */ jsx2(
+    Template4,
+    {
+      name,
+      JSDoc: { comments: getComments(operation) },
+      client,
+      hook,
+      params: params.toString(),
+      returnType: `SWRMutationResponse<${resultGenerics.join(", ")}>`,
+      dataReturnType
+    }
+  );
+}
+Mutation.File = function({ templates = defaultTemplates }) {
+  const {
+    plugin: {
+      options: {
+        extName,
+        client: { importPath }
+      }
+    }
+  } = useApp2();
+  const { getSchemas, getFile, getName } = useOperationManager2();
+  const operation = useOperation2();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTsName2], type: "type" });
+  const file = getFile(operation);
+  const fileType = getFile(operation, { pluginKey: [pluginTsName2] });
+  const factoryName = getName(operation, { type: "type" });
+  const Template4 = templates.default;
+  const factory = {
+    name: factoryName
+  };
+  return /* @__PURE__ */ jsx2(Parser, { language: "typescript", children: /* @__PURE__ */ jsxs2(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+    /* @__PURE__ */ jsx2(File.Import, { name: "useSWRMutation", path: "swr/mutation" }),
+    /* @__PURE__ */ jsx2(File.Import, { name: ["SWRMutationConfiguration", "SWRMutationResponse"], path: "swr/mutation", isTypeOnly: true }),
+    /* @__PURE__ */ jsx2(File.Import, { name: "client", path: importPath }),
+    /* @__PURE__ */ jsx2(File.Import, { name: ["ResponseConfig"], path: importPath, isTypeOnly: true }),
+    /* @__PURE__ */ jsx2(
+      File.Import,
+      {
+        extName,
+        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__ */ jsxs2(File.Source, { children: [
+      /* @__PURE__ */ jsx2(SchemaType, { factory }),
+      /* @__PURE__ */ jsx2(Mutation, { Template: Template4, factory })
+    ] })
+  ] }) });
+};
+Mutation.templates = defaultTemplates;
+
+// src/components/Query.tsx
+import { FunctionParams as FunctionParams3, URLPath as URLPath3 } from "@kubb/core/utils";
+import { Parser as Parser2, File as File2, Function as Function3, useApp as useApp4 } from "@kubb/react";
+import { pluginTsName as pluginTsName4 } from "@kubb/plugin-ts";
+import { useOperation as useOperation4, useOperationManager as useOperationManager4 } from "@kubb/plugin-oas/hooks";
+import { getASTParams as getASTParams3, getComments as getComments2 } from "@kubb/plugin-oas/utils";
+import { pluginZodName as pluginZodName2 } from "@kubb/plugin-zod";
+
+// src/components/QueryOptions.tsx
+import transformers2 from "@kubb/core/transformers";
+import { FunctionParams as FunctionParams2, URLPath as URLPath2 } from "@kubb/core/utils";
+import { useOperation as useOperation3, useOperationManager as useOperationManager3 } from "@kubb/plugin-oas/hooks";
+import { getASTParams as getASTParams2 } from "@kubb/plugin-oas/utils";
+import { Function as Function2, useApp as useApp3 } from "@kubb/react";
+import { pluginZodName } from "@kubb/plugin-zod";
+import { pluginTsName as pluginTsName3 } from "@kubb/plugin-ts";
+import { jsx as jsx3 } from "@kubb/react/jsx-runtime";
+function Template2({ name, params, generics, returnType, JSDoc, client, dataReturnType, parser }) {
+  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}, ...options.headers }` : void 0,
+    "...options"
+  ].filter(Boolean);
+  const resolvedClientOptions = `${transformers2.createIndent(4)}${clientOptions.join(`,
+${transformers2.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;
+  return /* @__PURE__ */ jsx3(Function2, { name, export: true, generics, returnType, params, JSDoc, children: `
+      return {
+        fetcher: async () => {
+          ${formData || ""}
+          const res = await client<${client.generics}>({
+            ${resolvedClientOptions}
+          })
+
+         ${returnRes}
+        },
+      }
+
+       ` });
+}
+var defaultTemplates2 = {
+  default: Template2
+};
+function QueryOptions({ factory, dataReturnType, Template: Template4 = defaultTemplates2.default }) {
+  const {
+    pluginManager,
+    plugin: {
+      key: pluginKey,
+      options: { parser }
+    }
+  } = useApp3();
+  const { getSchemas } = useOperationManager3();
+  const operation = useOperation3();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTsName3], type: "type" });
+  const zodSchemas = getSchemas(operation, { pluginKey: [pluginZodName], type: "function" });
+  const name = pluginManager.resolveName({
+    name: `${factory.name}QueryOptions`,
+    pluginKey
+  });
+  const contentType = operation.getContentType();
+  const generics = new FunctionParams2();
+  const params = new FunctionParams2();
+  const clientGenerics = ["TData", `${factory.name}['error']`];
+  const resultGenerics = ["TData", `${factory.name}['error']`];
+  generics.add([{ type: "TData", default: `${factory.name}['response']` }]);
+  params.add([
+    ...getASTParams2(schemas.pathParams, { typed: true }),
+    {
+      name: "params",
+      type: `${factory.name}['queryParams']`,
+      enabled: !!schemas.queryParams?.name,
+      required: false
+    },
+    {
+      name: "headers",
+      type: `${factory.name}['headerParams']`,
+      enabled: !!schemas.headerParams?.name,
+      required: false
+    },
+    {
+      name: "options",
+      type: `${factory.name}['client']['parameters']`,
+      default: "{}"
+    }
+  ]);
+  const client = {
+    withQueryParams: !!schemas.queryParams?.name,
+    withData: !!schemas.request?.name,
+    withPathParams: !!schemas.pathParams?.name,
+    withHeaders: !!schemas.headerParams?.name,
+    method: operation.method,
+    path: new URLPath2(operation.path),
+    generics: clientGenerics.join(", "),
+    contentType
+  };
+  return /* @__PURE__ */ jsx3(
+    Template4,
+    {
+      name,
+      params: params.toString(),
+      generics: generics.toString(),
+      returnType: `SWRConfiguration<${resultGenerics.join(", ")}>`,
+      client,
+      dataReturnType,
+      parser: parser === "zod" ? `${zodSchemas.response.name}.parse` : void 0
+    }
+  );
+}
+QueryOptions.templates = defaultTemplates2;
+
+// src/components/Query.tsx
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs3 } from "@kubb/react/jsx-runtime";
+function Template3({ name, generics, returnType, params, JSDoc, hook, client }) {
+  if (client.withQueryParams) {
+    return /* @__PURE__ */ jsx4(Fragment2, { children: /* @__PURE__ */ jsx4(Function3, { name, export: true, generics, returnType, params, JSDoc, children: `
+         const { query: queryOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
+
+         const url = ${client.path.template}
+         const query = ${hook.name}<${hook.generics}>(
+          shouldFetch ? [url, params]: null,
+          {
+            ...${hook.queryOptions},
+            ...queryOptions
+          }
+         )
+
+         return query
+         ` }) });
+  }
+  return /* @__PURE__ */ jsx4(Fragment2, { children: /* @__PURE__ */ jsx4(Function3, { name, export: true, generics, returnType, params, JSDoc, children: `
+       const { query: queryOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
+
+       const url = ${client.path.template}
+       const query = ${hook.name}<${hook.generics}>(
+        shouldFetch ? url : null,
+        {
+          ...${hook.queryOptions},
+          ...queryOptions
+        }
+       )
+
+       return query
+       ` }) });
+}
+var defaultTemplates3 = {
+  default: Template3
+};
+function Query({ factory, Template: Template4 = defaultTemplates3.default, QueryOptionsTemplate = QueryOptions.templates.default }) {
+  const {
+    pluginManager,
+    plugin: {
+      key: pluginKey,
+      options: { dataReturnType }
+    }
+  } = useApp4();
+  const operation = useOperation4();
+  const { getSchemas, getName } = useOperationManager4();
+  const schemas = getSchemas(operation, { pluginKey: [pluginTsName4], type: "type" });
+  const zodSchemas = getSchemas(operation, { pluginKey: [pluginZodName2], type: "function" });
+  const name = getName(operation, { type: "function" });
+  const queryOptionsName = pluginManager.resolveName({
+    name: `${factory.name}QueryOptions`,
+    pluginKey
+  });
+  const generics = new FunctionParams3();
+  const params = new FunctionParams3();
+  const queryParams = new FunctionParams3();
+  const client = {
+    method: operation.method,
+    path: new URLPath3(operation.path),
+    withQueryParams: !!schemas.queryParams?.name,
+    withData: !!schemas.request?.name,
+    withPathParams: !!schemas.pathParams?.name,
+    withHeaders: !!schemas.headerParams?.name
+  };
+  const resultGenerics = ["TData", `${factory.name}["error"]`];
+  generics.add([{ type: "TData", default: `${factory.name}["response"]` }]);
+  const queryOptionsGenerics = ["TData"];
+  params.add([
+    ...getASTParams3(schemas.pathParams, { typed: true }),
+    {
+      name: "params",
+      type: `${factory.name}['queryParams']`,
+      enabled: client.withQueryParams,
+      required: false
+    },
+    {
+      name: "headers",
+      type: `${factory.name}['headerParams']`,
+      enabled: client.withHeaders,
+      required: false
+    },
+    {
+      name: "options",
+      required: false,
+      type: `{
+        query?: SWRConfiguration<${resultGenerics.join(", ")}>,
+        client?: ${factory.name}['client']['parameters'],
+        shouldFetch?: boolean,
+      }`,
+      default: "{}"
+    }
+  ]);
+  queryParams.add([
+    ...getASTParams3(schemas.pathParams, { typed: false }),
+    {
+      name: "params",
+      enabled: client.withQueryParams,
+      required: false
+    },
+    {
+      name: "headers",
+      enabled: client.withHeaders,
+      required: false
+    },
+    {
+      name: "clientOptions",
+      required: false
+    }
+  ]);
+  const hook = {
+    name: "useSWR",
+    generics: [...resultGenerics, client.withQueryParams ? "[typeof url, typeof params] | null" : "typeof url | null"].join(", "),
+    queryOptions: `${queryOptionsName}<${queryOptionsGenerics.join(", ")}>(${queryParams.toString()})`
+  };
+  return /* @__PURE__ */ jsxs3(Fragment2, { children: [
+    /* @__PURE__ */ jsx4(QueryOptions, { factory, Template: QueryOptionsTemplate, dataReturnType }),
+    /* @__PURE__ */ jsx4(
+      Template4,
+      {
+        name,
+        generics: generics.toString(),
+        JSDoc: { comments: getComments2(operation) },
+        client,
+        hook,
+        params: params.toString(),
+        returnType: `SWRResponse<${resultGenerics.join(", ")}>`
+      }
+    )
+  ] });
+}
+Query.File = function({ templates }) {
+  const {
+    pluginManager,
+    plugin: {
+      options: {
+        extName,
+        client: { importPath },
+        parser
+      }
+    }
+  } = useApp4();
+  const { getSchemas, getFile, getName } = useOperationManager4();
+  const operation = useOperation4();
+  const file = getFile(operation);
+  const schemas = getSchemas(operation, { pluginKey: [pluginTsName4], type: "type" });
+  const zodSchemas = getSchemas(operation, { pluginKey: [pluginZodName2], type: "function" });
+  const fileType = getFile(operation, { pluginKey: [pluginTsName4] });
+  const fileZodSchemas = getFile(operation, {
+    pluginKey: [pluginZodName2]
+  });
+  const factoryName = getName(operation, { type: "type" });
+  const Template4 = templates?.query.default || defaultTemplates3.default;
+  const QueryOptionsTemplate = templates?.queryOptions.default || QueryOptions.templates.default;
+  const factory = {
+    name: factoryName
+  };
+  return /* @__PURE__ */ jsx4(Parser2, { language: "typescript", children: /* @__PURE__ */ jsxs3(File2, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+    parser === "zod" && /* @__PURE__ */ jsx4(File2.Import, { extName, name: [zodSchemas.response.name], root: file.path, path: fileZodSchemas.path }),
+    /* @__PURE__ */ jsx4(File2.Import, { name: "useSWR", path: "swr" }),
+    /* @__PURE__ */ jsx4(File2.Import, { name: ["SWRConfiguration", "SWRResponse"], path: "swr", isTypeOnly: true }),
+    /* @__PURE__ */ jsx4(File2.Import, { name: "client", path: importPath }),
+    /* @__PURE__ */ jsx4(File2.Import, { name: ["ResponseConfig"], path: importPath, isTypeOnly: true }),
+    /* @__PURE__ */ jsx4(
+      File2.Import,
+      {
+        extName,
+        name: [
+          schemas.request?.name,
+          schemas.response.name,
+          schemas.pathParams?.name,
+          schemas.queryParams?.name,
+          schemas.headerParams?.name,
+          ...schemas.statusCodes?.map((item) => item.name) || []
+        ].filter(Boolean),
+        root: file.path,
+        path: fileType.path,
+        isTypeOnly: true
+      }
+    ),
+    /* @__PURE__ */ jsxs3(File2.Source, { children: [
+      /* @__PURE__ */ jsx4(SchemaType, { factory }),
+      /* @__PURE__ */ jsx4(Query, { factory, Template: Template4, QueryOptionsTemplate })
+    ] })
+  ] }) });
+};
+Query.templates = defaultTemplates3;
+
+export {
+  Mutation,
+  QueryOptions,
+  Query
+};
+//# sourceMappingURL=chunk-ECJ346AA.js.map