/**
 * Generated by orval v8.9.1 🍺
 * Do not edit manually.
 * Api
 * API specification for The Astro Lounge
 * OpenAPI spec version: 0.1.0
 */
import {
  useMutation,
  useQuery
} from '@tanstack/react-query';
import type {
  MutationFunction,
  QueryFunction,
  QueryKey,
  UseMutationOptions,
  UseMutationResult,
  UseQueryOptions,
  UseQueryResult
} from '@tanstack/react-query';

import type {
  BookingConfirmation,
  BookingInput,
  ContactConfirmation,
  ContactInput,
  HealthStatus,
  MenuCategory,
  MenuItem
} from './api.schemas';

import { customFetch } from '../custom-fetch';
import type { ErrorType , BodyType } from '../custom-fetch';

type AwaitedInput<T> = PromiseLike<T> | T;

      type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;


type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];



export const getHealthCheckUrl = () => {




  return `/api/healthz`
}

/**
 * Returns server health status
 * @summary Health check
 */
export const healthCheck = async ( options?: RequestInit): Promise<HealthStatus> => {

  return customFetch<HealthStatus>(getHealthCheckUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getHealthCheckQueryKey = () => {
    return [
    `/api/healthz`
    ] as const;
    }


export const getHealthCheckQueryOptions = <TData = Awaited<ReturnType<typeof healthCheck>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof healthCheck>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

  const queryKey =  queryOptions?.queryKey ?? getHealthCheckQueryKey();



    const queryFn: QueryFunction<Awaited<ReturnType<typeof healthCheck>>> = ({ signal }) => healthCheck({ signal, ...requestOptions });





   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof healthCheck>>, TError, TData> & { queryKey: QueryKey }
}

export type HealthCheckQueryResult = NonNullable<Awaited<ReturnType<typeof healthCheck>>>
export type HealthCheckQueryError = ErrorType<unknown>


/**
 * @summary Health check
 */

export function useHealthCheck<TData = Awaited<ReturnType<typeof healthCheck>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof healthCheck>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getHealthCheckQueryOptions(options)

  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };

  return { ...query, queryKey: queryOptions.queryKey };
}







export const getListMenuItemsUrl = () => {




  return `/api/menu`
}

/**
 * @summary List all menu items
 */
export const listMenuItems = async ( options?: RequestInit): Promise<MenuItem[]> => {

  return customFetch<MenuItem[]>(getListMenuItemsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListMenuItemsQueryKey = () => {
    return [
    `/api/menu`
    ] as const;
    }


export const getListMenuItemsQueryOptions = <TData = Awaited<ReturnType<typeof listMenuItems>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listMenuItems>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

  const queryKey =  queryOptions?.queryKey ?? getListMenuItemsQueryKey();



    const queryFn: QueryFunction<Awaited<ReturnType<typeof listMenuItems>>> = ({ signal }) => listMenuItems({ signal, ...requestOptions });





   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof listMenuItems>>, TError, TData> & { queryKey: QueryKey }
}

export type ListMenuItemsQueryResult = NonNullable<Awaited<ReturnType<typeof listMenuItems>>>
export type ListMenuItemsQueryError = ErrorType<unknown>


/**
 * @summary List all menu items
 */

export function useListMenuItems<TData = Awaited<ReturnType<typeof listMenuItems>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listMenuItems>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListMenuItemsQueryOptions(options)

  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };

  return { ...query, queryKey: queryOptions.queryKey };
}







export const getListMenuCategoriesUrl = () => {




  return `/api/menu/categories`
}

/**
 * @summary List all menu categories with item counts
 */
export const listMenuCategories = async ( options?: RequestInit): Promise<MenuCategory[]> => {

  return customFetch<MenuCategory[]>(getListMenuCategoriesUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListMenuCategoriesQueryKey = () => {
    return [
    `/api/menu/categories`
    ] as const;
    }


export const getListMenuCategoriesQueryOptions = <TData = Awaited<ReturnType<typeof listMenuCategories>>, TError = ErrorType<unknown>>( options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listMenuCategories>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

  const queryKey =  queryOptions?.queryKey ?? getListMenuCategoriesQueryKey();



    const queryFn: QueryFunction<Awaited<ReturnType<typeof listMenuCategories>>> = ({ signal }) => listMenuCategories({ signal, ...requestOptions });





   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof listMenuCategories>>, TError, TData> & { queryKey: QueryKey }
}

export type ListMenuCategoriesQueryResult = NonNullable<Awaited<ReturnType<typeof listMenuCategories>>>
export type ListMenuCategoriesQueryError = ErrorType<unknown>


/**
 * @summary List all menu categories with item counts
 */

export function useListMenuCategories<TData = Awaited<ReturnType<typeof listMenuCategories>>, TError = ErrorType<unknown>>(
  options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof listMenuCategories>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getListMenuCategoriesQueryOptions(options)

  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };

  return { ...query, queryKey: queryOptions.queryKey };
}







export const getGetMenuItemUrl = (id: number,) => {




  return `/api/menu/${id}`
}

/**
 * @summary Get a single menu item
 */
export const getMenuItem = async (id: number, options?: RequestInit): Promise<MenuItem> => {

  return customFetch<MenuItem>(getGetMenuItemUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMenuItemQueryKey = (id: number,) => {
    return [
    `/api/menu/${id}`
    ] as const;
    }


export const getGetMenuItemQueryOptions = <TData = Awaited<ReturnType<typeof getMenuItem>>, TError = ErrorType<void>>(id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getMenuItem>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

const {query: queryOptions, request: requestOptions} = options ?? {};

  const queryKey =  queryOptions?.queryKey ?? getGetMenuItemQueryKey(id);



    const queryFn: QueryFunction<Awaited<ReturnType<typeof getMenuItem>>> = ({ signal }) => getMenuItem(id, { signal, ...requestOptions });





   return  { queryKey, queryFn, enabled: !!(id), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getMenuItem>>, TError, TData> & { queryKey: QueryKey }
}

export type GetMenuItemQueryResult = NonNullable<Awaited<ReturnType<typeof getMenuItem>>>
export type GetMenuItemQueryError = ErrorType<void>


/**
 * @summary Get a single menu item
 */

export function useGetMenuItem<TData = Awaited<ReturnType<typeof getMenuItem>>, TError = ErrorType<void>>(
 id: number, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getMenuItem>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

 ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {

  const queryOptions = getGetMenuItemQueryOptions(id,options)

  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };

  return { ...query, queryKey: queryOptions.queryKey };
}







export const getCreateBookingUrl = () => {




  return `/api/bookings`
}

/**
 * @summary Submit a booking request (sends email)
 */
export const createBooking = async (bookingInput: BookingInput, options?: RequestInit): Promise<BookingConfirmation> => {

  return customFetch<BookingConfirmation>(getCreateBookingUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      bookingInput,)
  }
);}




export const getCreateBookingMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createBooking>>, TError,{data: BodyType<BookingInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createBooking>>, TError,{data: BodyType<BookingInput>}, TContext> => {

const mutationKey = ['createBooking'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createBooking>>, {data: BodyType<BookingInput>}> = (props) => {
          const {data} = props ?? {};

          return  createBooking(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateBookingMutationResult = NonNullable<Awaited<ReturnType<typeof createBooking>>>
    export type CreateBookingMutationBody = BodyType<BookingInput>
    export type CreateBookingMutationError = ErrorType<void>

    /**
 * @summary Submit a booking request (sends email)
 */
export const useCreateBooking = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createBooking>>, TError,{data: BodyType<BookingInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createBooking>>,
        TError,
        {data: BodyType<BookingInput>},
        TContext
      > => {
      return useMutation(getCreateBookingMutationOptions(options));
    }

export const getSubmitContactUrl = () => {




  return `/api/contact`
}

/**
 * @summary Submit a contact message (sends email)
 */
export const submitContact = async (contactInput: ContactInput, options?: RequestInit): Promise<ContactConfirmation> => {

  return customFetch<ContactConfirmation>(getSubmitContactUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      contactInput,)
  }
);}




export const getSubmitContactMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof submitContact>>, TError,{data: BodyType<ContactInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof submitContact>>, TError,{data: BodyType<ContactInput>}, TContext> => {

const mutationKey = ['submitContact'];
const {mutation: mutationOptions, request: requestOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, request: undefined};




      const mutationFn: MutationFunction<Awaited<ReturnType<typeof submitContact>>, {data: BodyType<ContactInput>}> = (props) => {
          const {data} = props ?? {};

          return  submitContact(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type SubmitContactMutationResult = NonNullable<Awaited<ReturnType<typeof submitContact>>>
    export type SubmitContactMutationBody = BodyType<ContactInput>
    export type SubmitContactMutationError = ErrorType<void>

    /**
 * @summary Submit a contact message (sends email)
 */
export const useSubmitContact = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof submitContact>>, TError,{data: BodyType<ContactInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof submitContact>>,
        TError,
        {data: BodyType<ContactInput>},
        TContext
      > => {
      return useMutation(getSubmitContactMutationOptions(options));
    }