@kubb/plugin-react-query 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/__snapshots__/pathParamsTypeInline/getPetById.ts

@@ -1,62 +0,0 @@
-import client from "@kubb/plugin-client/client";
-import type { UseBaseQueryOptions, UseQueryResult, QueryKey, WithRequired } from "@tanstack/react-query";
-import { useQuery } from "@tanstack/react-query";
-
- type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
-
- type GetPetById = {
-    data: GetPetByIdQueryResponse;
-    error: GetPetById400 | GetPetById404;
-    request: never;
-    pathParams: GetPetByIdPathParams;
-    queryParams: never;
-    headerParams: never;
-    response: GetPetByIdQueryResponse;
-    client: {
-        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
-        return: Awaited<ReturnType<GetPetByIdClient>>;
-    };
-};
-
- export const getPetByIdQueryKey = (petId: GetPetByIdPathParams["petId"]) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
-
- export type GetPetByIdQueryKey = ReturnType<typeof getPetByIdQueryKey>;
-
- export function getPetByIdQueryOptions<TData = GetPetById["response"], TQueryData = GetPetById["response"]>(petId: GetPetByIdPathParams["petId"], options: GetPetById["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData>, "queryKey"> {
-    const queryKey = getPetByIdQueryKey(petId);
-    return {
-        queryKey,
-        queryFn: async () => {
-            const res = await client<GetPetById["data"], GetPetById["error"]>({
-                method: "get",
-                url: `/pet/${petId}`,
-                ...options
-            });
-            return res.data;
-        },
-    };
-}
-
- /**
- * @description Returns a single pet
- * @summary Find pet by ID
- * @link /pet/:petId
- */
-export function getPetById<TData = GetPetById["response"], TQueryData = GetPetById["response"], TQueryKey extends QueryKey = GetPetByIdQueryKey>(petId: GetPetByIdPathParams["petId"], options: {
-    query?: Partial<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData, TQueryKey>>;
-    client?: GetPetById["client"]["parameters"];
-} = {}): UseQueryResult<TData, GetPetById["error"]> & {
-    queryKey: TQueryKey;
-} {
-    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
-    const queryKey = queryOptions?.queryKey ?? getPetByIdQueryKey(petId);
-    const query = useQuery<GetPetById["data"], GetPetById["error"], TData, any>({
-        ...getPetByIdQueryOptions<TData, TQueryData>(petId, clientOptions),
-        queryKey,
-        ...queryOptions
-    }) as UseQueryResult<TData, GetPetById["error"]> & {
-        queryKey: TQueryKey;
-    };
-    query.queryKey = queryKey as TQueryKey;
-    return query;
-}

package/src/__snapshots__/pathParamsTypeObject/getPetById.ts

@@ -1,68 +0,0 @@
-import client from "@kubb/plugin-client/client";
-import type { UseBaseQueryOptions, UseQueryResult, QueryKey, WithRequired } from "@tanstack/react-query";
-import { useQuery } from "@tanstack/react-query";
-
- type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
-
- type GetPetById = {
-    data: GetPetByIdQueryResponse;
-    error: GetPetById400 | GetPetById404;
-    request: never;
-    pathParams: GetPetByIdPathParams;
-    queryParams: never;
-    headerParams: never;
-    response: GetPetByIdQueryResponse;
-    client: {
-        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
-        return: Awaited<ReturnType<GetPetByIdClient>>;
-    };
-};
-
- export const getPetByIdQueryKey = ({ petId }: {
-    petId: GetPetByIdPathParams["petId"];
-}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
-
- export type GetPetByIdQueryKey = ReturnType<typeof getPetByIdQueryKey>;
-
- export function getPetByIdQueryOptions<TData = GetPetById["response"], TQueryData = GetPetById["response"]>({ petId }: {
-    petId: GetPetByIdPathParams["petId"];
-}, options: GetPetById["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData>, "queryKey"> {
-    const queryKey = getPetByIdQueryKey({ petId });
-    return {
-        queryKey,
-        queryFn: async () => {
-            const res = await client<GetPetById["data"], GetPetById["error"]>({
-                method: "get",
-                url: `/pet/${petId}`,
-                ...options
-            });
-            return res.data;
-        },
-    };
-}
-
- /**
- * @description Returns a single pet
- * @summary Find pet by ID
- * @link /pet/:petId
- */
-export function getPetById<TData = GetPetById["response"], TQueryData = GetPetById["response"], TQueryKey extends QueryKey = GetPetByIdQueryKey>({ petId }: {
-    petId: GetPetByIdPathParams["petId"];
-}, options: {
-    query?: Partial<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData, TQueryKey>>;
-    client?: GetPetById["client"]["parameters"];
-} = {}): UseQueryResult<TData, GetPetById["error"]> & {
-    queryKey: TQueryKey;
-} {
-    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
-    const queryKey = queryOptions?.queryKey ?? getPetByIdQueryKey({ petId });
-    const query = useQuery<GetPetById["data"], GetPetById["error"], TData, any>({
-        ...getPetByIdQueryOptions<TData, TQueryData>({ petId }, clientOptions),
-        queryKey,
-        ...queryOptions
-    }) as UseQueryResult<TData, GetPetById["error"]> & {
-        queryKey: TQueryKey;
-    };
-    query.queryKey = queryKey as TQueryKey;
-    return query;
-}

package/src/__snapshots__/queryOptions/getPetById.ts

@@ -1,41 +0,0 @@
-import client from "@kubb/plugin-client/client";
-import type { UseBaseQueryOptions, QueryKey, WithRequired } from "@tanstack/react-query";
-
- type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
-
- type GetPetById = {
-    data: GetPetByIdQueryResponse;
-    error: GetPetById400 | GetPetById404;
-    request: never;
-    pathParams: GetPetByIdPathParams;
-    queryParams: never;
-    headerParams: never;
-    response: GetPetByIdQueryResponse;
-    client: {
-        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
-        return: Awaited<ReturnType<GetPetByIdClient>>;
-    };
-};
-
- export const getPetByIdQueryKey = ({ petId }: {
-    petId: GetPetByIdPathParams["petId"];
-}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
-
- export type GetPetByIdQueryKey = ReturnType<typeof getPetByIdQueryKey>;
-
- export function getPetByIdQueryOptions<TData = GetPetById["response"], TQueryData = GetPetById["response"]>({ petId }: {
-    petId: GetPetByIdPathParams["petId"];
-}, options: GetPetById["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData>, "queryKey"> {
-    const queryKey = getPetByIdQueryKey({ petId });
-    return {
-        queryKey,
-        queryFn: async () => {
-            const res = await client<GetPetById["data"], GetPetById["error"]>({
-                method: "get",
-                url: `/pet/${petId}`,
-                ...options
-            });
-            return res.data;
-        },
-    };
-}

package/src/__snapshots__/queryWithoutQueryOptions/getPetById.ts

@@ -1,51 +0,0 @@
-import client from "@kubb/plugin-client/client";
-import type { UseBaseQueryOptions, UseQueryResult, QueryKey } from "@tanstack/react-query";
-import { useQuery } from "@tanstack/react-query";
-
- type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
-
- type GetPetById = {
-    data: GetPetByIdQueryResponse;
-    error: GetPetById400 | GetPetById404;
-    request: never;
-    pathParams: GetPetByIdPathParams;
-    queryParams: never;
-    headerParams: never;
-    response: GetPetByIdQueryResponse;
-    client: {
-        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
-        return: Awaited<ReturnType<GetPetByIdClient>>;
-    };
-};
-
- export const getPetByIdQueryKey = ({ petId }: {
-    petId: GetPetByIdPathParams["petId"];
-}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
-
- export type GetPetByIdQueryKey = ReturnType<typeof getPetByIdQueryKey>;
-
- /**
- * @description Returns a single pet
- * @summary Find pet by ID
- * @link /pet/:petId
- */
-export function getPetById<TData = GetPetById["response"], TQueryData = GetPetById["response"], TQueryKey extends QueryKey = GetPetByIdQueryKey>({ petId }: {
-    petId: GetPetByIdPathParams["petId"];
-}, options: {
-    query?: Partial<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData, TQueryKey>>;
-    client?: GetPetById["client"]["parameters"];
-} = {}): UseQueryResult<TData, GetPetById["error"]> & {
-    queryKey: TQueryKey;
-} {
-    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
-    const queryKey = queryOptions?.queryKey ?? getPetByIdQueryKey({ petId });
-    const query = useQuery<GetPetById["data"], GetPetById["error"], TData, any>({
-        ...getPetByIdQueryOptions<TData, TQueryData>({ petId }, clientOptions),
-        queryKey,
-        ...queryOptions
-    }) as UseQueryResult<TData, GetPetById["error"]> & {
-        queryKey: TQueryKey;
-    };
-    query.queryKey = queryKey as TQueryKey;
-    return query;
-}

package/src/__snapshots__/variablesTypeMutate/deletePet.ts

@@ -1,24 +0,0 @@
-import client from "@kubb/plugin-client/client";
-import type { QueryKey } from "@tanstack/react-query";
-
- type DeletePetClient = typeof client<DeletePetMutationResponse, DeletePet400, never>;
-
- type DeletePet = {
-    data: DeletePetMutationResponse;
-    error: DeletePet400;
-    request: never;
-    pathParams: DeletePetPathParams;
-    queryParams: never;
-    headerParams: DeletePetHeaderParams;
-    response: DeletePetMutationResponse;
-    client: {
-        parameters: Partial<Parameters<DeletePetClient>[0]>;
-        return: Awaited<ReturnType<DeletePetClient>>;
-    };
-};
-
- export const deletePetQueryKey = ({ petId }: {
-    petId: DeletePetPathParams["petId"];
-}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
-
- export type DeletePetQueryKey = ReturnType<typeof deletePetQueryKey>;

package/src/components/QueryImports.tsx

@@ -1,167 +0,0 @@
-import { PackageManager } from '@kubb/core'
-import { File } from '@kubb/react'
-
-import { getImportNames, reactQueryDepRegex } from '../utils.ts'
-
-import type { ReactNode } from 'react'
-
-type TemplateProps = {
-  /**
-   * Path to @tanstack-query
-   */
-  path: string
-  /**
-   * Override the path of 'useQuery'
-   * @default 'path'
-   */
-  hookPath: string | undefined
-  optionsType: string
-  queryOptions: string | undefined
-  resultType: string
-  hookName: string
-  isInfinite: boolean
-}
-
-function Template({ path, hookPath = path, isInfinite, hookName, queryOptions, optionsType, resultType }: TemplateProps): ReactNode {
-  return (
-    <>
-      <File.Import name={[optionsType, resultType]} path={path} isTypeOnly />
-      <File.Import name={[hookName]} path={hookPath} />
-
-      {queryOptions && <File.Import name={[queryOptions].filter(Boolean)} path={path} />}
-      <File.Import name={['QueryKey', 'WithRequired', isInfinite ? 'InfiniteData' : undefined].filter(Boolean)} path={path} isTypeOnly />
-    </>
-  )
-}
-
-type FrameworkProps = Partial<TemplateProps> & {
-  context: {
-    isInfinite: boolean
-    isSuspense: boolean
-  }
-}
-
-const defaultTemplates = {
-  get react() {
-    return function ({ context, hookPath, ...rest }: FrameworkProps): ReactNode {
-      const importNames = getImportNames()
-      const isV5 = new PackageManager().isValidSync(reactQueryDepRegex, '>=5')
-      const { isInfinite, isSuspense } = context
-
-      return (
-        <Template
-          isInfinite={isInfinite}
-          {...(isSuspense ? importNames.querySuspense.react : isInfinite ? importNames.queryInfinite.react : importNames.query.react)}
-          queryOptions={isV5 ? (isInfinite ? 'infiniteQueryOptions' : 'queryOptions') : undefined}
-          hookPath={hookPath}
-          {...rest}
-        />
-      )
-    }
-  },
-  get solid() {
-    return function ({ context, hookPath, ...rest }: FrameworkProps): ReactNode {
-      const importNames = getImportNames()
-      const isV5 = new PackageManager().isValidSync(reactQueryDepRegex, '>=5')
-      const { isInfinite } = context
-
-      return (
-        <Template
-          isInfinite={isInfinite}
-          {...(isInfinite ? importNames.queryInfinite.solid : importNames.query.solid)}
-          queryOptions={isV5 ? (isInfinite ? 'infiniteQueryOptions' : 'queryOptions') : undefined}
-          hookPath={hookPath}
-          {...rest}
-        />
-      )
-    }
-  },
-  get svelte() {
-    return function ({ context, hookPath, ...rest }: FrameworkProps): ReactNode {
-      const importNames = getImportNames()
-      const isV5 = new PackageManager().isValidSync(reactQueryDepRegex, '>=5')
-      const { isInfinite } = context
-
-      return (
-        <Template
-          isInfinite={isInfinite}
-          {...(isInfinite ? importNames.queryInfinite.svelte : importNames.query.svelte)}
-          queryOptions={isV5 ? (isInfinite ? 'infiniteQueryOptions' : 'queryOptions') : undefined}
-          hookPath={hookPath}
-          {...rest}
-        />
-      )
-    }
-  },
-  get vue() {
-    return function ({ context, hookPath, ...rest }: FrameworkProps): ReactNode {
-      const importNames = getImportNames()
-      const isV5 = new PackageManager().isValidSync(reactQueryDepRegex, '>=5')
-      const { isInfinite } = context
-      const path = '@tanstack/vue-query'
-
-      return (
-        <>
-          {isV5 && (
-            <>
-              <Template
-                isInfinite={isInfinite}
-                {...(isInfinite ? importNames.queryInfinite.vue : importNames.query.vue)}
-                queryOptions={isInfinite ? 'infiniteQueryOptions' : 'queryOptions'}
-                hookPath={hookPath}
-                {...rest}
-              />
-              <File.Import name={['QueryObserverOptions']} path={path} isTypeOnly />
-            </>
-          )}
-
-          {!isV5 && isInfinite && (
-            <>
-              <File.Import name={[importNames.queryInfinite.vue.resultType]} path={path} isTypeOnly />
-              <File.Import name={[importNames.queryInfinite.vue.optionsType]} path={'@tanstack/vue-query/build/lib/types'} isTypeOnly />
-              <File.Import name={[importNames.queryInfinite.vue.hookName]} path={path} />
-            </>
-          )}
-
-          {!isV5 && !isInfinite && (
-            <>
-              <File.Import name={[importNames.query.vue.resultType]} path={path} isTypeOnly />
-              <File.Import name={[importNames.query.vue.optionsType]} path={'@tanstack/vue-query/build/lib/types'} isTypeOnly />
-              <File.Import name={[importNames.query.vue.hookName]} path={path} />
-            </>
-          )}
-          <File.Import name={['unref']} path={'vue'} />
-          <File.Import name={['MaybeRef']} path={'vue'} isTypeOnly />
-          <File.Import name={['QueryKey', 'WithRequired']} path={path} isTypeOnly />
-        </>
-      )
-    }
-  },
-} as const
-
-type Props = {
-  hookPath: string | undefined
-  isInfinite: boolean
-  /**
-   * Only for React and v5
-   */
-  isSuspense: boolean
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  Template?: React.ComponentType<FrameworkProps>
-}
-
-export function QueryImports({ hookPath, isInfinite, isSuspense, Template = defaultTemplates.react }: Props): ReactNode {
-  return (
-    <Template
-      hookPath={hookPath}
-      context={{
-        isInfinite,
-        isSuspense,
-      }}
-    />
-  )
-}
-
-QueryImports.templates = defaultTemplates

package/src/components/SchemaType.tsx

@@ -1,59 +0,0 @@
-import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { File, Type, useApp } from '@kubb/react'
-
-import type { ReactNode } from 'react'
-import type { PluginReactQuery } from '../types.ts'
-import { pluginTsName } from '@kubb/plugin-ts'
-
-export function SchemaType(): ReactNode {
-  const {
-    plugin: {
-      options: { dataReturnType },
-    },
-  } = useApp<PluginReactQuery>()
-  const { getSchemas, getName } = 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 factoryName = getName(operation, { type: 'type' })
-
-  const clientType = `${factoryName}Client`
-  const isFormData = operation.getContentType() === 'multipart/form-data'
-
-  return (
-    <>
-      <File.Source name={clientType} isTypeOnly>
-        <Type name={clientType}>{`typeof client<${TResponse}, ${TError}, ${isFormData ? 'FormData' : TRequest}>`}</Type>
-      </File.Source>
-      <File.Source name={factoryName} isTypeOnly>
-        <Type name={factoryName}>
-          {`
-        {
-          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}>>
-          }
-        }
-        `}
-        </Type>
-      </File.Source>
-    </>
-  )
-}

package/src/components/__snapshots__/gen/showPetById.ts

@@ -1,67 +0,0 @@
-type GetPetsUuidClient = typeof client<GetPetsUuidQueryResponse, never, never>
-
-type GetPetsUuid = 
-            {
-              data: GetPetsUuidQueryResponse
-              error: never
-              request: never
-              pathParams: never
-              queryParams: never
-              headerParams: never
-              response: GetPetsUuidQueryResponse
-              client: {
-                parameters: Partial<Parameters<GetPetsUuidClient>[0]>
-                return: Awaited<ReturnType<GetPetsUuidClient>>
-              }
-            }
-
-export const GetPetsUuidQueryKey = () =>   [{ url: '/pets/:uuid', params: {uuid:uuid} }] as const
-
-export type GetPetsUuidQueryKey = ReturnType<typeof GetPetsUuidQueryKey>
-
-export function GetPetsUuidQueryOptions<TData = GetPetsUuid["response"], TQueryData = GetPetsUuid["response"]>(options: GetPetsUuid['client']['parameters'] = {}): WithRequired<UseBaseQueryOptions<GetPetsUuid['response'], GetPetsUuid["error"], TData, TQueryData>, 'queryKey'> {
-  
-           const queryKey = GetPetsUuidQueryKey()
-    
-           return {
-             queryKey,
-             queryFn: async () => {
-               
-               
-               const res = await client<GetPetsUuid['data'],GetPetsUuid['error']>({
-                    method: "get",
-        url: `/pets/${uuid}`,
-        ...options
-               })
-    
-               return res.data
-             },
-                 
-           }
-    
-           
-}
-
-/**
- * @link /pets/:uuid
- */
-export function useGetPetsUuid<TData = GetPetsUuid["response"], TQueryData = GetPetsUuid["response"], TQueryKey extends QueryKey = GetPetsUuidQueryKey>(options: {
-        query?: Partial<UseBaseQueryOptions<GetPetsUuid['response'], GetPetsUuid['error'], TData, TQueryData, TQueryKey>>,
-        client?: GetPetsUuid['client']['parameters']
-    } = {}): UseQueryResult<TData, GetPetsUuid['error']> & { queryKey: TQueryKey } {
-  
-           const { query: queryOptions, client: clientOptions = {} } = options ?? {}
-           const queryKey = queryOptions?.queryKey ?? GetPetsUuidQueryKey()
-    
-           const query = useQuery<GetPetsUuid['data'], GetPetsUuid['error'], TData, any>({
-            ...GetPetsUuidQueryOptions<TData, TQueryData>(clientOptions),
-            queryKey,
-            ...queryOptions
-          }) as UseQueryResult<TData, GetPetsUuid['error']> & { queryKey: TQueryKey }
-    
-          query.queryKey = queryKey as TQueryKey
-    
-          return query
-    
-           
-}

package/src/components/__snapshots__/gen/useCreatePets.ts

@@ -1,46 +0,0 @@
-type CreatePetsClient = typeof client<CreatePetsMutationResponse, never, CreatePetsMutationRequest>
-
-type CreatePets = 
-            {
-              data: CreatePetsMutationResponse
-              error: never
-              request: CreatePetsMutationRequest
-              pathParams: CreatePetsPathParams
-              queryParams: CreatePetsQueryParams
-              headerParams: CreatePetsHeaderParams
-              response: CreatePetsMutationResponse
-              client: {
-                parameters: Partial<Parameters<CreatePetsClient>[0]>
-                return: Awaited<ReturnType<CreatePetsClient>>
-              }
-            }
-
-/**
- * @summary Create a pet
- * @link /pets/:uuid
- */
-export function useCreatePets(uuid: CreatePetsPathParams["uuid"], headers: CreatePets['headerParams'], params?: CreatePets['queryParams'], options: {
-          mutation?: UseMutationOptions<CreatePets["response"], CreatePets["error"], CreatePets["request"]>,
-          client?: CreatePets['client']['parameters']
-      } = {}) {
-  
-             const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
-    
-             return useMutation({
-               mutationFn: async(data) => {
-                 
-                 
-                 const res = await client<CreatePets["data"], CreatePets["error"], CreatePets["request"]>({
-                      method: "post",
-        url: `/pets/${uuid}`,
-        params,
-        data,
-        headers: { ...headers, ...clientOptions.headers },
-        ...clientOptions
-                 })
-    
-                 return res.data
-               },
-               ...mutationOptions
-             })
-}

package/src/components/__snapshots__/gen/useCreatePetsMutate.ts

@@ -1,46 +0,0 @@
-type CreatePetsClient = typeof client<CreatePetsMutationResponse, never, CreatePetsMutationRequest>
-
-type CreatePets = 
-            {
-              data: CreatePetsMutationResponse
-              error: never
-              request: CreatePetsMutationRequest
-              pathParams: CreatePetsPathParams
-              queryParams: CreatePetsQueryParams
-              headerParams: CreatePetsHeaderParams
-              response: CreatePetsMutationResponse
-              client: {
-                parameters: Partial<Parameters<CreatePetsClient>[0]>
-                return: Awaited<ReturnType<CreatePetsClient>>
-              }
-            }
-
-/**
- * @summary Create a pet
- * @link /pets/:uuid
- */
-export function useCreatePets(options: {
-          mutation?: UseMutationOptions<CreatePets["response"], CreatePets["error"], { uuid: CreatePetsPathParams["uuid"]; params?: CreatePets['queryParams']; headers: CreatePets['headerParams']; data: CreatePets['request'] }>,
-          client?: CreatePets['client']['parameters']
-      } = {}) {
-  
-             const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
-    
-             return useMutation({
-               mutationFn: async({ uuid, headers, data, params }) => {
-                 
-                 
-                 const res = await client<CreatePets["data"], CreatePets["error"], CreatePets["request"]>({
-                      method: "post",
-        url: `/pets/${uuid}`,
-        params,
-        data,
-        headers: { ...headers, ...clientOptions.headers },
-        ...clientOptions
-                 })
-    
-                 return res.data
-               },
-               ...mutationOptions
-             })
-}