openapi-ts / examples / openapi-ts-tanstack-vue-query / src / client / @tanstack / vue-query.gen.ts

// This file is auto-generated by @hey-api/openapi-ts

import { type DefaultError, queryOptions, type UseMutationOptions } from '@tanstack/vue-query'

import { client } from '../client.gen'
import {
  addPet,
  createUser,
  createUsersWithListInput,
  deleteOrder,
  deletePet,
  deleteUser,
  findPetsByStatus,
  findPetsByTags,
  getInventory,
  getOrderById,
  getPetById,
  getUserByName,
  loginUser,
  logoutUser,
  type Options,
  placeOrder,
  updatePet,
  updatePetWithForm,
  updateUser,
  uploadFile
} from '../sdk.gen'
import type {
  AddPetData,
  AddPetResponse,
  CreateUserData,
  CreateUserResponse,
  CreateUsersWithListInputData,
  CreateUsersWithListInputResponse,
  DeleteOrderData,
  DeletePetData,
  DeleteUserData,
  FindPetsByStatusData,
  FindPetsByStatusResponse,
  FindPetsByTagsData,
  FindPetsByTagsResponse,
  GetInventoryData,
  GetInventoryResponse,
  GetOrderByIdData,
  GetOrderByIdResponse,
  GetPetByIdData,
  GetPetByIdResponse,
  GetUserByNameData,
  GetUserByNameResponse,
  LoginUserData,
  LoginUserResponse,
  LogoutUserData,
  PlaceOrderData,
  PlaceOrderResponse,
  UpdatePetData,
  UpdatePetResponse,
  UpdatePetWithFormData,
  UpdatePetWithFormResponse,
  UpdateUserData,
  UploadFileData,
  UploadFileResponse
} from '../types.gen'

/**
 * Add a new pet to the store.
 *
 * Add a new pet to the store.
 */
export const addPetMutation = (
  options?: Partial<Options<AddPetData>>
): UseMutationOptions<AddPetResponse, DefaultError, Options<AddPetData>> => {
  const mutationOptions: UseMutationOptions<AddPetResponse, DefaultError, Options<AddPetData>> = {
    mutationFn: async (fnOptions) => {
      const { data } = await addPet({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

/**
 * Update an existing pet.
 *
 * Update an existing pet by Id.
 */
export const updatePetMutation = (
  options?: Partial<Options<UpdatePetData>>
): UseMutationOptions<UpdatePetResponse, DefaultError, Options<UpdatePetData>> => {
  const mutationOptions: UseMutationOptions<
    UpdatePetResponse,
    DefaultError,
    Options<UpdatePetData>
  > = {
    mutationFn: async (fnOptions) => {
      const { data } = await updatePet({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

export type QueryKey<TOptions extends Options> = [
  Pick<TOptions, 'baseUrl' | 'body' | 'headers' | 'path' | 'query'> & {
    _id: string
    _infinite?: boolean
    tags?: ReadonlyArray<string>
  }
]

const createQueryKey = <TOptions extends Options>(
  id: string,
  options?: TOptions,
  infinite?: boolean,
  tags?: ReadonlyArray<string>
): [QueryKey<TOptions>[0]] => {
  const params: QueryKey<TOptions>[0] = {
    _id: id,
    baseUrl: options?.baseUrl || (options?.client ?? client).getConfig().baseUrl
  } as QueryKey<TOptions>[0]
  if (infinite) {
    params._infinite = infinite
  }
  if (tags) {
    params.tags = tags
  }
  if (options?.body) {
    params.body = options.body
  }
  if (options?.headers) {
    params.headers = options.headers
  }
  if (options?.path) {
    params.path = options.path
  }
  if (options?.query) {
    params.query = options.query
  }
  return [params]
}

export const findPetsByStatusQueryKey = (options: Options<FindPetsByStatusData>) =>
  createQueryKey('findPetsByStatus', options)

/**
 * Finds Pets by status.
 *
 * Multiple status values can be provided with comma separated strings.
 */
export const findPetsByStatusOptions = (options: Options<FindPetsByStatusData>) =>
  queryOptions<
    FindPetsByStatusResponse,
    DefaultError,
    FindPetsByStatusResponse,
    ReturnType<typeof findPetsByStatusQueryKey>
  >({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await findPetsByStatus({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: findPetsByStatusQueryKey(options)
  })

export const findPetsByTagsQueryKey = (options: Options<FindPetsByTagsData>) =>
  createQueryKey('findPetsByTags', options)

/**
 * Finds Pets by tags.
 *
 * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
 */
export const findPetsByTagsOptions = (options: Options<FindPetsByTagsData>) =>
  queryOptions<
    FindPetsByTagsResponse,
    DefaultError,
    FindPetsByTagsResponse,
    ReturnType<typeof findPetsByTagsQueryKey>
  >({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await findPetsByTags({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: findPetsByTagsQueryKey(options)
  })

/**
 * Deletes a pet.
 *
 * Delete a pet.
 */
export const deletePetMutation = (
  options?: Partial<Options<DeletePetData>>
): UseMutationOptions<unknown, DefaultError, Options<DeletePetData>> => {
  const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeletePetData>> = {
    mutationFn: async (fnOptions) => {
      const { data } = await deletePet({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

export const getPetByIdQueryKey = (options: Options<GetPetByIdData>) =>
  createQueryKey('getPetById', options)

/**
 * Find pet by ID.
 *
 * Returns a single pet.
 */
export const getPetByIdOptions = (options: Options<GetPetByIdData>) =>
  queryOptions<
    GetPetByIdResponse,
    DefaultError,
    GetPetByIdResponse,
    ReturnType<typeof getPetByIdQueryKey>
  >({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await getPetById({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: getPetByIdQueryKey(options)
  })

/**
 * Updates a pet in the store with form data.
 *
 * Updates a pet resource based on the form data.
 */
export const updatePetWithFormMutation = (
  options?: Partial<Options<UpdatePetWithFormData>>
): UseMutationOptions<UpdatePetWithFormResponse, DefaultError, Options<UpdatePetWithFormData>> => {
  const mutationOptions: UseMutationOptions<
    UpdatePetWithFormResponse,
    DefaultError,
    Options<UpdatePetWithFormData>
  > = {
    mutationFn: async (fnOptions) => {
      const { data } = await updatePetWithForm({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

/**
 * Uploads an image.
 *
 * Upload image of the pet.
 */
export const uploadFileMutation = (
  options?: Partial<Options<UploadFileData>>
): UseMutationOptions<UploadFileResponse, DefaultError, Options<UploadFileData>> => {
  const mutationOptions: UseMutationOptions<
    UploadFileResponse,
    DefaultError,
    Options<UploadFileData>
  > = {
    mutationFn: async (fnOptions) => {
      const { data } = await uploadFile({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

export const getInventoryQueryKey = (options?: Options<GetInventoryData>) =>
  createQueryKey('getInventory', options)

/**
 * Returns pet inventories by status.
 *
 * Returns a map of status codes to quantities.
 */
export const getInventoryOptions = (options?: Options<GetInventoryData>) =>
  queryOptions<
    GetInventoryResponse,
    DefaultError,
    GetInventoryResponse,
    ReturnType<typeof getInventoryQueryKey>
  >({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await getInventory({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: getInventoryQueryKey(options)
  })

/**
 * Place an order for a pet.
 *
 * Place a new order in the store.
 */
export const placeOrderMutation = (
  options?: Partial<Options<PlaceOrderData>>
): UseMutationOptions<PlaceOrderResponse, DefaultError, Options<PlaceOrderData>> => {
  const mutationOptions: UseMutationOptions<
    PlaceOrderResponse,
    DefaultError,
    Options<PlaceOrderData>
  > = {
    mutationFn: async (fnOptions) => {
      const { data } = await placeOrder({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

/**
 * Delete purchase order by identifier.
 *
 * For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API errors.
 */
export const deleteOrderMutation = (
  options?: Partial<Options<DeleteOrderData>>
): UseMutationOptions<unknown, DefaultError, Options<DeleteOrderData>> => {
  const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeleteOrderData>> = {
    mutationFn: async (fnOptions) => {
      const { data } = await deleteOrder({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

export const getOrderByIdQueryKey = (options: Options<GetOrderByIdData>) =>
  createQueryKey('getOrderById', options)

/**
 * Find purchase order by ID.
 *
 * For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.
 */
export const getOrderByIdOptions = (options: Options<GetOrderByIdData>) =>
  queryOptions<
    GetOrderByIdResponse,
    DefaultError,
    GetOrderByIdResponse,
    ReturnType<typeof getOrderByIdQueryKey>
  >({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await getOrderById({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: getOrderByIdQueryKey(options)
  })

/**
 * Create user.
 *
 * This can only be done by the logged in user.
 */
export const createUserMutation = (
  options?: Partial<Options<CreateUserData>>
): UseMutationOptions<CreateUserResponse, DefaultError, Options<CreateUserData>> => {
  const mutationOptions: UseMutationOptions<
    CreateUserResponse,
    DefaultError,
    Options<CreateUserData>
  > = {
    mutationFn: async (fnOptions) => {
      const { data } = await createUser({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

/**
 * Creates list of users with given input array.
 *
 * Creates list of users with given input array.
 */
export const createUsersWithListInputMutation = (
  options?: Partial<Options<CreateUsersWithListInputData>>
): UseMutationOptions<
  CreateUsersWithListInputResponse,
  DefaultError,
  Options<CreateUsersWithListInputData>
> => {
  const mutationOptions: UseMutationOptions<
    CreateUsersWithListInputResponse,
    DefaultError,
    Options<CreateUsersWithListInputData>
  > = {
    mutationFn: async (fnOptions) => {
      const { data } = await createUsersWithListInput({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

export const loginUserQueryKey = (options?: Options<LoginUserData>) =>
  createQueryKey('loginUser', options)

/**
 * Logs user into the system.
 *
 * Log into the system.
 */
export const loginUserOptions = (options?: Options<LoginUserData>) =>
  queryOptions<
    LoginUserResponse,
    DefaultError,
    LoginUserResponse,
    ReturnType<typeof loginUserQueryKey>
  >({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await loginUser({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: loginUserQueryKey(options)
  })

export const logoutUserQueryKey = (options?: Options<LogoutUserData>) =>
  createQueryKey('logoutUser', options)

/**
 * Logs out current logged in user session.
 *
 * Log user out of the system.
 */
export const logoutUserOptions = (options?: Options<LogoutUserData>) =>
  queryOptions<unknown, DefaultError, unknown, ReturnType<typeof logoutUserQueryKey>>({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await logoutUser({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: logoutUserQueryKey(options)
  })

/**
 * Delete user resource.
 *
 * This can only be done by the logged in user.
 */
export const deleteUserMutation = (
  options?: Partial<Options<DeleteUserData>>
): UseMutationOptions<unknown, DefaultError, Options<DeleteUserData>> => {
  const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeleteUserData>> = {
    mutationFn: async (fnOptions) => {
      const { data } = await deleteUser({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}

export const getUserByNameQueryKey = (options: Options<GetUserByNameData>) =>
  createQueryKey('getUserByName', options)

/**
 * Get user by user name.
 *
 * Get user detail based on username.
 */
export const getUserByNameOptions = (options: Options<GetUserByNameData>) =>
  queryOptions<
    GetUserByNameResponse,
    DefaultError,
    GetUserByNameResponse,
    ReturnType<typeof getUserByNameQueryKey>
  >({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await getUserByName({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true
      })
      return data
    },
    queryKey: getUserByNameQueryKey(options)
  })

/**
 * Update user resource.
 *
 * This can only be done by the logged in user.
 */
export const updateUserMutation = (
  options?: Partial<Options<UpdateUserData>>
): UseMutationOptions<unknown, DefaultError, Options<UpdateUserData>> => {
  const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<UpdateUserData>> = {
    mutationFn: async (fnOptions) => {
      const { data } = await updateUser({
        ...options,
        ...fnOptions,
        throwOnError: true
      })
      return data
    }
  }
  return mutationOptions
}