/**
 * Generated by orval v8.23.0 🍺
 * Do not edit manually.
 * Api
 * API specification for Roleta UMR Equipamentos
 * 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 {
  AdminStatus,
  DrawResult,
  ErrorResponse,
  HealthStatus,
  ParticipantInput,
  TogglePrizeInput
} 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];



const withQueryKey = <T extends object, K>(query: T, queryKey: K): T & { queryKey: K } => {
  const result = { queryKey } as T & { queryKey: K };
  for (const key of Object.keys(query)) {
    // The explicit queryKey always wins, matching the previous
    // `{ ...query, queryKey }` spread where it was set last.
    if (key === 'queryKey') continue;
    Object.defineProperty(result, key, {
      enumerable: true,
      configurable: true,
      get: () => (query as Record<string, unknown>)[key],
    });
  }
  return result;
};

export const getHealthCheckUrl = () => {




  return `/api/healthz`
}

/**
 * Returns server health status
 * @summary Health check
 */
export const healthCheck = async ( options?: Parameters<typeof customFetch>[1]): 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 withQueryKey(query, queryOptions.queryKey);
}







export const getRegisterParticipantUrl = () => {




  return `/api/participants`
}

/**
 * Registers a participant and returns the drawn prize based on cargo restrictions and daily limits
 * @summary Register participant and draw prize
 */
export const registerParticipant = async (participantInput: ParticipantInput, options?: Parameters<typeof customFetch>[1]): Promise<DrawResult> => {

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





export const getRegisterParticipantMutationOptions = <TError = ErrorType<ErrorResponse>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof registerParticipant>>, TError,{data: BodyType<ParticipantInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof registerParticipant>>, TError,{data: BodyType<ParticipantInput>}, TContext> => {

const mutationKey = ['registerParticipant'];
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 registerParticipant>>, {data: BodyType<ParticipantInput>}> = (props) => {
          const {data} = props ?? {};

          return  registerParticipant(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type RegisterParticipantMutationResult = NonNullable<Awaited<ReturnType<typeof registerParticipant>>>
    export type RegisterParticipantMutationBody = BodyType<ParticipantInput>
    export type RegisterParticipantMutationError = ErrorType<ErrorResponse>

    /**
 * @summary Register participant and draw prize
 */
export const useRegisterParticipant = <TError = ErrorType<ErrorResponse>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof registerParticipant>>, TError,{data: BodyType<ParticipantInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof registerParticipant>>,
        TError,
        {data: BodyType<ParticipantInput>},
        TContext
      > => {
      return useMutation(getRegisterParticipantMutationOptions(options));
    }

export const getGetAdminStatusUrl = () => {




  return `/api/admin/status`
}

/**
 * Returns daily prize counters and enabled flags for special prizes
 * @summary Get admin status
 */
export const getAdminStatus = async ( options?: Parameters<typeof customFetch>[1]): Promise<AdminStatus> => {

  return customFetch<AdminStatus>(getGetAdminStatusUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetAdminStatusQueryKey = () => {
    return [
    `/api/admin/status`
    ] as const;
    }


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

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

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



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





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

export type GetAdminStatusQueryResult = NonNullable<Awaited<ReturnType<typeof getAdminStatus>>>
export type GetAdminStatusQueryError = ErrorType<unknown>


/**
 * @summary Get admin status
 */

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

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

  const queryOptions = getGetAdminStatusQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getAdminResetUrl = () => {




  return `/api/admin/reset`
}

/**
 * Resets all daily counters and state.json for a new day
 * @summary Reset daily counters
 */
export const adminReset = async ( options?: Parameters<typeof customFetch>[1]): Promise<AdminStatus> => {

  return customFetch<AdminStatus>(getAdminResetUrl(),
  {
    ...options,
    method: 'POST'


  }
);}





export const getAdminResetMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof adminReset>>, TError,void, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof adminReset>>, TError,void, TContext> => {

const mutationKey = ['adminReset'];
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 adminReset>>, void> = () => {


          return  adminReset(requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminResetMutationResult = NonNullable<Awaited<ReturnType<typeof adminReset>>>

    export type AdminResetMutationError = ErrorType<unknown>

    /**
 * @summary Reset daily counters
 */
export const useAdminReset = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof adminReset>>, TError,void, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof adminReset>>,
        TError,
        void,
        TContext
      > => {
      return useMutation(getAdminResetMutationOptions(options));
    }

export const getAdminTogglePrizeUrl = () => {




  return `/api/admin/toggle-prize`
}

/**
 * Toggles Camarote Barretão or Treinamento de Bombas on/off
 * @summary Enable or disable a special prize
 */
export const adminTogglePrize = async (togglePrizeInput: TogglePrizeInput, options?: Parameters<typeof customFetch>[1]): Promise<AdminStatus> => {

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





export const getAdminTogglePrizeMutationOptions = <TError = ErrorType<ErrorResponse>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof adminTogglePrize>>, TError,{data: BodyType<TogglePrizeInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof adminTogglePrize>>, TError,{data: BodyType<TogglePrizeInput>}, TContext> => {

const mutationKey = ['adminTogglePrize'];
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 adminTogglePrize>>, {data: BodyType<TogglePrizeInput>}> = (props) => {
          const {data} = props ?? {};

          return  adminTogglePrize(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AdminTogglePrizeMutationResult = NonNullable<Awaited<ReturnType<typeof adminTogglePrize>>>
    export type AdminTogglePrizeMutationBody = BodyType<TogglePrizeInput>
    export type AdminTogglePrizeMutationError = ErrorType<ErrorResponse>

    /**
 * @summary Enable or disable a special prize
 */
export const useAdminTogglePrize = <TError = ErrorType<ErrorResponse>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof adminTogglePrize>>, TError,{data: BodyType<TogglePrizeInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof adminTogglePrize>>,
        TError,
        {data: BodyType<TogglePrizeInput>},
        TContext
      > => {
      return useMutation(getAdminTogglePrizeMutationOptions(options));
    }