@kubb/plugin-svelte-query 3.0.0-alpha.20

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@kubb/plugin-svelte-query",
+  "version": "3.0.0-alpha.20",
+  "description": "Generator svelte-query hooks",
+  "keywords": [
+    "faker",
+    "faker.js",
+    "msw",
+    "mock",
+    "mocking",
+    "plugins",
+    "kubb",
+    "codegen",
+    "swagger",
+    "openapi"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-svelte-query"
+  },
+  "license": "MIT",
+  "author": "Stijn Van Hulle <stijn@stijnvanhulle.be",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs",
+      "default": "./dist/components.cjs"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**"
+  ],
+  "dependencies": {
+    "@kubb/core": "3.0.0-alpha.20",
+    "@kubb/fs": "3.0.0-alpha.20",
+    "@kubb/oas": "3.0.0-alpha.20",
+    "@kubb/plugin-oas": "3.0.0-alpha.20",
+    "@kubb/plugin-ts": "3.0.0-alpha.20",
+    "@kubb/plugin-zod": "3.0.0-alpha.20",
+    "@kubb/react": "3.0.0-alpha.20"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.6",
+    "react": "^18.3.1",
+    "tsup": "^8.2.4",
+    "typescript": "^5.6.2",
+    "@kubb/config-ts": "3.0.0-alpha.20",
+    "@kubb/config-tsup": "3.0.0-alpha.20"
+  },
+  "peerDependencies": {
+    "@kubb/react": "3.0.0-alpha.20"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --apply-unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsup --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/src/components/Mutation.tsx

@@ -0,0 +1,133 @@
+import { File, Function, FunctionParams } from '@kubb/react'
+
+import { type Operation, isOptional } from '@kubb/oas'
+import { Client } from '@kubb/plugin-client/components'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
+import type { ReactNode } from 'react'
+import type { PluginSvelteQuery } from '../types.ts'
+
+type Props = {
+  /**
+   * Name of the function
+   */
+  name: string
+  typeName: string
+  clientName: string
+  typeSchemas: OperationSchemas
+  operation: Operation
+  dataReturnType: PluginSvelteQuery['resolvedOptions']['client']['dataReturnType']
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+}
+
+type GetParamsProps = {
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+  dataReturnType: PluginSvelteQuery['resolvedOptions']['client']['dataReturnType']
+  typeSchemas: OperationSchemas
+}
+
+function getParams({ dataReturnType, typeSchemas }: GetParamsProps) {
+  const mutateParams = FunctionParams.factory({
+    ...getPathParams(typeSchemas.pathParams, { typed: true }),
+    data: typeSchemas.request?.name
+      ? {
+          type: typeSchemas.request?.name,
+          optional: isOptional(typeSchemas.request?.schema),
+        }
+      : undefined,
+    params: typeSchemas.queryParams?.name
+      ? {
+          type: typeSchemas.queryParams?.name,
+          optional: isOptional(typeSchemas.queryParams?.schema),
+        }
+      : undefined,
+    headers: typeSchemas.headerParams?.name
+      ? {
+          type: typeSchemas.headerParams?.name,
+          optional: isOptional(typeSchemas.headerParams?.schema),
+        }
+      : undefined,
+  })
+
+  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
+  const TRequest = mutateParams.toConstructor({ valueAsType: true })
+
+  return FunctionParams.factory({
+    options: {
+      type: `
+{
+  mutation?: CreateMutationOptions<${[TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'unknown', `{${TRequest}`].join(', ')}>,
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>>` : 'Partial<RequestConfig>'},
+}
+`,
+      default: '{}',
+    },
+  })
+}
+
+export function Mutation({ name, clientName, pathParamsType, dataReturnType, typeSchemas, operation }: Props): ReactNode {
+  const params = getParams({
+    pathParamsType,
+    dataReturnType,
+    typeSchemas,
+  })
+
+  const clientParams = Client.getParams({
+    typeSchemas,
+    pathParamsType,
+  })
+
+  const mutationParams = FunctionParams.factory({
+    data: {
+      // No use of pathParams because useMutation can only take one argument in object form,
+      // see https://tanstack.com/query/latest/docs/framework/react/reference/useMutation#usemutation
+      mode: 'object',
+      //TODO rename with value
+      children: {
+        ...getPathParams(typeSchemas.pathParams, { typed: true }),
+        data: typeSchemas.request?.name
+          ? {
+              type: typeSchemas.request?.name,
+              optional: isOptional(typeSchemas.request?.schema),
+            }
+          : undefined,
+        params: typeSchemas.queryParams?.name
+          ? {
+              type: typeSchemas.queryParams?.name,
+              optional: isOptional(typeSchemas.queryParams?.schema),
+            }
+          : undefined,
+        headers: typeSchemas.headerParams?.name
+          ? {
+              type: typeSchemas.headerParams?.name,
+              optional: isOptional(typeSchemas.headerParams?.schema),
+            }
+          : undefined,
+      },
+    },
+  })
+
+  return (
+    <File.Source name={name} isExportable isIndexable>
+      <Function
+        name={name}
+        export
+        params={params.toConstructor()}
+        JSDoc={{
+          comments: getComments(operation),
+        }}
+      >
+        {`
+        const { mutation: mutationOptions, client: config = {} } = options ?? {}
+
+        return createMutation({
+          mutationFn: async(${mutationParams.toConstructor()}) => {
+            return ${clientName}(${clientParams.toCall()})
+          },
+          ...mutationOptions
+        })
+    `}
+      </Function>
+    </File.Source>
+  )
+}

package/src/components/Query.tsx

@@ -0,0 +1,120 @@
+import { File, Function, FunctionParams } from '@kubb/react'
+
+import { type Operation, isOptional } from '@kubb/oas'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
+import type { ReactNode } from 'react'
+import type { PluginSvelteQuery } from '../types.ts'
+import { QueryKey } from './QueryKey.tsx'
+import { QueryOptions } from './QueryOptions.tsx'
+
+type Props = {
+  /**
+   * Name of the function
+   */
+  name: string
+  queryOptionsName: string
+  queryKeyName: string
+  queryKeyTypeName: string
+  typeSchemas: OperationSchemas
+  operation: Operation
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+  dataReturnType: PluginSvelteQuery['resolvedOptions']['client']['dataReturnType']
+}
+
+type GetParamsProps = {
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+  dataReturnType: PluginSvelteQuery['resolvedOptions']['client']['dataReturnType']
+  typeSchemas: OperationSchemas
+}
+
+function getParams({ pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
+  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
+
+  return FunctionParams.factory({
+    pathParams: {
+      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
+      children: getPathParams(typeSchemas.pathParams, { typed: true }),
+    },
+    data: typeSchemas.request?.name
+      ? {
+          type: typeSchemas.request?.name,
+          optional: isOptional(typeSchemas.request?.schema),
+        }
+      : undefined,
+    params: typeSchemas.queryParams?.name
+      ? {
+          type: typeSchemas.queryParams?.name,
+          optional: isOptional(typeSchemas.queryParams?.schema),
+        }
+      : undefined,
+    headers: typeSchemas.headerParams?.name
+      ? {
+          type: typeSchemas.headerParams?.name,
+          optional: isOptional(typeSchemas.headerParams?.schema),
+        }
+      : undefined,
+    options: {
+      type: `
+{
+  query?: Partial<CreateBaseQueryOptions<${[TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'unknown', 'TData', 'TQueryData', 'TQueryKey'].join(', ')}>>,
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>>` : 'Partial<RequestConfig>'}
+}
+`,
+      default: '{}',
+    },
+  })
+}
+
+export function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, pathParamsType, dataReturnType, typeSchemas, operation }: Props): ReactNode {
+  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
+  const returnType = `CreateQueryResult<${['TData', typeSchemas.errors?.map((item) => item.name).join(' | ') || 'unknown'].join(', ')}> & { queryKey: TQueryKey }`
+  const generics = [`TData = ${TData}`, `TQueryData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`]
+
+  const queryKeyParams = QueryKey.getParams({
+    pathParamsType,
+    typeSchemas,
+  })
+  const queryOptionsParams = QueryOptions.getParams({
+    pathParamsType,
+    typeSchemas,
+  })
+  const params = getParams({
+    pathParamsType,
+    dataReturnType,
+    typeSchemas,
+  })
+
+  const queryOptions = `${queryOptionsName}(${queryOptionsParams.toCall()}) as unknown as CreateBaseQueryOptions`
+
+  return (
+    <File.Source name={name} isExportable isIndexable>
+      <Function
+        name={name}
+        export
+        generics={generics.join(', ')}
+        params={params.toConstructor()}
+        JSDoc={{
+          comments: getComments(operation),
+        }}
+      >
+        {`
+       const { query: queryOptions, client: config = {} } = options ?? {}
+       const queryKey = queryOptions?.queryKey ?? ${queryKeyName}(${queryKeyParams.toCall()})
+
+       const query = createQuery({
+        ...${queryOptions},
+        queryKey,
+        ...queryOptions as unknown as Omit<CreateBaseQueryOptions, "queryKey">
+       }) as ${returnType}
+
+       query.queryKey = queryKey as TQueryKey
+
+       return query
+       `}
+      </Function>
+    </File.Source>
+  )
+}
+
+Query.getParams = getParams

package/src/components/QueryKey.tsx

@@ -0,0 +1,73 @@
+import { URLPath } from '@kubb/core/utils'
+import { getPathParams } from '@kubb/plugin-oas/utils'
+import { File, Function, FunctionParams, Type } from '@kubb/react'
+
+import { type Operation, isOptional } from '@kubb/oas'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import type { ReactNode } from 'react'
+import type { PluginSvelteQuery } from '../types'
+
+type Props = {
+  name: string
+  typeName: string
+  typeSchemas: OperationSchemas
+  operation: Operation
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+  keysFn: ((keys: unknown[]) => unknown[]) | undefined
+}
+
+type GetParamsProps = {
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+  typeSchemas: OperationSchemas
+}
+
+function getParams({ pathParamsType, typeSchemas }: GetParamsProps) {
+  return FunctionParams.factory({
+    pathParams: {
+      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
+      children: getPathParams(typeSchemas.pathParams, { typed: true }),
+    },
+    data: typeSchemas.request?.name
+      ? {
+          type: typeSchemas.request?.name,
+          optional: isOptional(typeSchemas.request?.schema),
+        }
+      : undefined,
+    params: typeSchemas.queryParams?.name
+      ? {
+          type: typeSchemas.queryParams?.name,
+          optional: isOptional(typeSchemas.queryParams?.schema),
+        }
+      : undefined,
+  })
+}
+
+export function QueryKey({ name, typeSchemas, pathParamsType, operation, typeName, keysFn = (name) => name }: Props): ReactNode {
+  const path = new URLPath(operation.path)
+  const params = getParams({ pathParamsType, typeSchemas })
+  const keys = [
+    path.toObject({
+      type: 'path',
+      stringify: true,
+    }),
+    typeSchemas.queryParams?.name ? '...(params ? [params] : [])' : undefined,
+    typeSchemas.request?.name ? '...(data ? [data] : [])' : undefined,
+  ].filter(Boolean)
+
+  return (
+    <>
+      <File.Source name={name} isExportable isIndexable>
+        <Function.Arrow name={name} export params={params.toConstructor()} singleLine>
+          {`[${keysFn(keys).join(', ')}] as const`}
+        </Function.Arrow>
+      </File.Source>
+      <File.Source name={typeName} isExportable isIndexable isTypeOnly>
+        <Type name={typeName} export>
+          {`ReturnType<typeof ${name}>`}
+        </Type>
+      </File.Source>
+    </>
+  )
+}
+
+QueryKey.getParams = getParams

package/src/components/QueryOptions.tsx

@@ -0,0 +1,84 @@
+import { getPathParams } from '@kubb/plugin-oas/utils'
+import { File, Function, FunctionParams } from '@kubb/react'
+
+import type { ReactNode } from 'react'
+
+import { isOptional } from '@kubb/oas'
+import { Client } from '@kubb/plugin-client/components'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import type { PluginSvelteQuery } from '../types.ts'
+import { QueryKey } from './QueryKey.tsx'
+
+type Props = {
+  name: string
+  clientName: string
+  queryKeyName: string
+  typeSchemas: OperationSchemas
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+}
+
+type GetParamsProps = {
+  pathParamsType: PluginSvelteQuery['resolvedOptions']['pathParamsType']
+  typeSchemas: OperationSchemas
+}
+
+function getParams({ pathParamsType, typeSchemas }: GetParamsProps) {
+  return FunctionParams.factory({
+    pathParams: {
+      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
+      children: getPathParams(typeSchemas.pathParams, { typed: true }),
+    },
+    data: typeSchemas.request?.name
+      ? {
+          type: typeSchemas.request?.name,
+          optional: isOptional(typeSchemas.request?.schema),
+        }
+      : undefined,
+    params: typeSchemas.queryParams?.name
+      ? {
+          type: typeSchemas.queryParams?.name,
+          optional: isOptional(typeSchemas.queryParams?.schema),
+        }
+      : undefined,
+    headers: typeSchemas.headerParams?.name
+      ? {
+          type: typeSchemas.headerParams?.name,
+          optional: isOptional(typeSchemas.headerParams?.schema),
+        }
+      : undefined,
+    config: {
+      type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>>` : 'Partial<RequestConfig>',
+      default: '{}',
+    },
+  })
+}
+
+export function QueryOptions({ name, clientName, typeSchemas, pathParamsType, queryKeyName }: Props): ReactNode {
+  const params = getParams({ pathParamsType, typeSchemas })
+  const clientParams = Client.getParams({
+    typeSchemas,
+    pathParamsType,
+  })
+  const queryKeyParams = QueryKey.getParams({
+    pathParamsType,
+    typeSchemas,
+  })
+
+  return (
+    <File.Source name={name} isExportable isIndexable>
+      <Function name={name} export params={params.toConstructor()}>
+        {`
+      const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
+      return queryOptions({
+       queryKey,
+       queryFn: async () => {
+          return ${clientName}(${clientParams.toCall()})
+       },
+      })
+`}
+      </Function>
+    </File.Source>
+  )
+}
+
+QueryOptions.getParams = getParams

package/src/components/index.ts

@@ -0,0 +1,4 @@
+export { Mutation } from './Mutation.tsx'
+export { Query } from './Query.tsx'
+export { QueryKey } from './QueryKey.tsx'
+export { QueryOptions } from './QueryOptions.tsx'

package/src/generators/__snapshots__/clientDataReturnTypeFull.ts

@@ -0,0 +1,50 @@
+import client from "@kubb/plugin-client/client";
+import type { RequestConfig, ResponseConfig } from "@kubb/plugin-client/client";
+import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
+import { createQuery, queryOptions } from "@tanstack/svelte-query";
+
+ export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
+
+ export type FindPetsByTagsQueryKey = ReturnType<typeof findPetsByTagsQueryKey>;
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+async function findPetsByTags(headers: FindPetsByTagsHeaderParams, params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "get", url: `/pet/findByTags`, params, headers: { ...headers, ...config.headers }, ...config });
+    return { ...res, data: findPetsByTagsQueryResponse.parse(res.data) };
+}
+
+ export function findPetsByTagsQueryOptions(headers: FindPetsByTagsHeaderParams, params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const queryKey = findPetsByTagsQueryKey(params);
+    return queryOptions({
+        queryKey,
+        queryFn: async () => {
+            return findPetsByTags(headers, params, config);
+        },
+    });
+}
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export function createFindPetsByTags<TData = ResponseConfig<FindPetsByTagsQueryResponse>, TQueryData = ResponseConfig<FindPetsByTagsQueryResponse>, TQueryKey extends QueryKey = FindPetsByTagsQueryKey>(headers: FindPetsByTagsHeaderParams, params?: FindPetsByTagsQueryParams, options: {
+    query?: Partial<CreateBaseQueryOptions<ResponseConfig<FindPetsByTagsQueryResponse>, FindPetsByTags400, TData, TQueryData, TQueryKey>>;
+    client?: Partial<RequestConfig>;
+} = {}) {
+    const { query: queryOptions, client: config = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? findPetsByTagsQueryKey(params);
+    const query = createQuery({
+        ...findPetsByTagsQueryOptions(headers, params, config) as unknown as CreateBaseQueryOptions,
+        queryKey,
+        ...queryOptions as unknown as Omit<CreateBaseQueryOptions, "queryKey">
+    }) as CreateQueryResult<TData, FindPetsByTags400> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/generators/__snapshots__/clientGetImportPath.ts

@@ -0,0 +1,50 @@
+import client from "axios";
+import type { QueryKey, CreateBaseQueryOptions, CreateQueryResult } from "@tanstack/svelte-query";
+import type { RequestConfig } from "axios";
+import { createQuery, queryOptions } from "@tanstack/svelte-query";
+
+ export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
+
+ export type FindPetsByTagsQueryKey = ReturnType<typeof findPetsByTagsQueryKey>;
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+async function findPetsByTags(headers: FindPetsByTagsHeaderParams, params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "get", url: `/pet/findByTags`, params, headers: { ...headers, ...config.headers }, ...config });
+    return findPetsByTagsQueryResponse.parse(res.data);
+}
+
+ export function findPetsByTagsQueryOptions(headers: FindPetsByTagsHeaderParams, params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const queryKey = findPetsByTagsQueryKey(params);
+    return queryOptions({
+        queryKey,
+        queryFn: async () => {
+            return findPetsByTags(headers, params, config);
+        },
+    });
+}
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export function createFindPetsByTags<TData = FindPetsByTagsQueryResponse, TQueryData = FindPetsByTagsQueryResponse, TQueryKey extends QueryKey = FindPetsByTagsQueryKey>(headers: FindPetsByTagsHeaderParams, params?: FindPetsByTagsQueryParams, options: {
+    query?: Partial<CreateBaseQueryOptions<FindPetsByTagsQueryResponse, FindPetsByTags400, TData, TQueryData, TQueryKey>>;
+    client?: Partial<RequestConfig>;
+} = {}) {
+    const { query: queryOptions, client: config = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? findPetsByTagsQueryKey(params);
+    const query = createQuery({
+        ...findPetsByTagsQueryOptions(headers, params, config) as unknown as CreateBaseQueryOptions,
+        queryKey,
+        ...queryOptions as unknown as Omit<CreateBaseQueryOptions, "queryKey">
+    }) as CreateQueryResult<TData, FindPetsByTags400> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/generators/__snapshots__/clientPostImportPath.ts

@@ -0,0 +1,38 @@
+import client from "axios";
+import type { CreateMutationOptions } from "@tanstack/svelte-query";
+import type { RequestConfig } from "axios";
+import { createMutation } from "@tanstack/svelte-query";
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+async function updatePetWithForm(petId: UpdatePetWithFormPathParams["petId"], data?: UpdatePetWithFormMutationRequest, params?: UpdatePetWithFormQueryParams, config: Partial<RequestConfig<UpdatePetWithFormMutationRequest>> = {}) {
+    const res = await client<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormMutationRequest>({ method: "post", url: `/pet/${petId}`, params, data, ...config });
+    return updatePetWithFormMutationResponse.parse(res.data);
+}
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+export function createUpdatePetWithForm(options: {
+    mutation?: CreateMutationOptions<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, {
+        petId: UpdatePetWithFormPathParams["petId"];
+        data?: UpdatePetWithFormMutationRequest;
+        params?: UpdatePetWithFormQueryParams;
+    }>;
+    client?: Partial<RequestConfig<UpdatePetWithFormMutationRequest>>;
+} = {}) {
+    const { mutation: mutationOptions, client: config = {} } = options ?? {};
+    return createMutation({
+        mutationFn: async ({ petId, data, params }: {
+            petId: UpdatePetWithFormPathParams["petId"];
+            data?: UpdatePetWithFormMutationRequest;
+            params?: UpdatePetWithFormQueryParams;
+        }) => {
+            return updatePetWithForm(petId, data, params, config);
+        },
+        ...mutationOptions
+    });
+}