/**
 * Generated by orval v8.23.0 🍺
 * Do not edit manually.
 * Api
 * API operativa de Y.E. Transport & Constructors
 * OpenAPI spec version: 1.0.0
 */
import {
  useMutation,
  useQuery
} from '@tanstack/react-query';
import type {
  MutationFunction,
  QueryFunction,
  QueryKey,
  UseMutationOptions,
  UseMutationResult,
  UseQueryOptions,
  UseQueryResult
} from '@tanstack/react-query';

import type {
  ActivityItem,
  AdminSecondFactorCodeIssued,
  AttendanceInput,
  AttendanceRecord,
  AttendanceScanInput,
  AttendanceScanResult,
  AuthLoginResponse,
  AuthSecondFactorRequiredResponse,
  Client,
  ClientInput,
  ClientUpdate,
  ContactInput,
  CsrfResponse,
  CurrentUser,
  DashboardSummary,
  DeviceDecisionInput,
  DeviceRegistrationInput,
  DeviceStatus,
  Document,
  DocumentInput,
  DocumentUpdate,
  Employee,
  EmployeeInput,
  EmployeeUpdate,
  Equipment,
  EquipmentInput,
  EquipmentUpdate,
  HealthStatus,
  ImpersonationSession,
  LeadReceipt,
  ListEmployeesParams,
  LoginInput,
  Material,
  MaterialInput,
  MaterialUpdate,
  MobileCredentialIssueInput,
  MobileCredentialIssued,
  MobileLoginInput,
  MobileLoginResponse,
  MobileUser,
  PlatformRecord,
  PlatformRecordInput,
  Policy,
  PolicyInput,
  PolicyUpdate,
  Project,
  ProjectDetail,
  ProjectInput,
  ProjectQrResource,
  ProjectUpdate,
  PublicContent,
  PublicEntry,
  PublicEntryInput,
  PublicEntryUpdate,
  PublicOverview,
  QrDisplayChallenge,
  Quote,
  QuoteInput,
  QuoteUpdate,
  SecurityAttempt,
  SecurityEvent,
  Settings,
  SettingsUpdate,
  StartImpersonationInput,
  SupervisorAttendanceCorrection,
  SupervisorLeaveReview,
  SupervisorSummary,
  Worksite,
  WorksiteInput,
  WorksiteSecurityConfig,
  WorksiteUpdate
} 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 getGetPublicOverviewUrl = () => {




  return `/api/public/overview`
}

/**
 * @summary Obtiene el resumen público de la compañía
 */
export const getPublicOverview = async ( options?: Parameters<typeof customFetch>[1]): Promise<PublicOverview> => {

  return customFetch<PublicOverview>(getGetPublicOverviewUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetPublicOverviewQueryKey = () => {
    return [
    `/api/public/overview`
    ] as const;
    }


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

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

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



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





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

export type GetPublicOverviewQueryResult = NonNullable<Awaited<ReturnType<typeof getPublicOverview>>>
export type GetPublicOverviewQueryError = ErrorType<unknown>


/**
 * @summary Obtiene el resumen público de la compañía
 */

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

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

  const queryOptions = getGetPublicOverviewQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getGetPublicContentUrl = () => {




  return `/api/public/content`
}

/**
 * @summary Devuelve los reemplazos de texto público
 */
export const getPublicContent = async ( options?: Parameters<typeof customFetch>[1]): Promise<PublicContent> => {

  return customFetch<PublicContent>(getGetPublicContentUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetPublicContentQueryKey = () => {
    return [
    `/api/public/content`
    ] as const;
    }


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

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

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



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





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

export type GetPublicContentQueryResult = NonNullable<Awaited<ReturnType<typeof getPublicContent>>>
export type GetPublicContentQueryError = ErrorType<unknown>


/**
 * @summary Devuelve los reemplazos de texto público
 */

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

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

  const queryOptions = getGetPublicContentQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListPublicShowcaseUrl = () => {




  return `/api/public/showcase`
}

/**
 * @summary Lista trabajos, servicios, equipo, materiales y herramientas publicados
 */
export const listPublicShowcase = async ( options?: Parameters<typeof customFetch>[1]): Promise<PublicEntry[]> => {

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


  }
);}





export const getListPublicShowcaseQueryKey = () => {
    return [
    `/api/public/showcase`
    ] as const;
    }


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

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

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



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





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

export type ListPublicShowcaseQueryResult = NonNullable<Awaited<ReturnType<typeof listPublicShowcase>>>
export type ListPublicShowcaseQueryError = ErrorType<unknown>


/**
 * @summary Lista trabajos, servicios, equipo, materiales y herramientas publicados
 */

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

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

  const queryOptions = getListPublicShowcaseQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListPublicPostsUrl = () => {




  return `/api/public/posts`
}

/**
 * @summary Lista artículos SEO publicados
 */
export const listPublicPosts = async ( options?: Parameters<typeof customFetch>[1]): Promise<PublicEntry[]> => {

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


  }
);}





export const getListPublicPostsQueryKey = () => {
    return [
    `/api/public/posts`
    ] as const;
    }


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

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

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



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





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

export type ListPublicPostsQueryResult = NonNullable<Awaited<ReturnType<typeof listPublicPosts>>>
export type ListPublicPostsQueryError = ErrorType<unknown>


/**
 * @summary Lista artículos SEO publicados
 */

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

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

  const queryOptions = getListPublicPostsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListPublicLegalUrl = () => {




  return `/api/public/legal`
}

/**
 * @summary Lista páginas legales públicas
 */
export const listPublicLegal = async ( options?: Parameters<typeof customFetch>[1]): Promise<PublicEntry[]> => {

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


  }
);}





export const getListPublicLegalQueryKey = () => {
    return [
    `/api/public/legal`
    ] as const;
    }


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

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

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



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





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

export type ListPublicLegalQueryResult = NonNullable<Awaited<ReturnType<typeof listPublicLegal>>>
export type ListPublicLegalQueryError = ErrorType<unknown>


/**
 * @summary Lista páginas legales públicas
 */

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

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

  const queryOptions = getListPublicLegalQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getGetPublicEntryUrl = (kind: 'showcase' | 'post' | 'legal',
    slug: string,) => {




  return `/api/public/entries/${kind}/${slug}`
}

/**
 * @summary Obtiene una publicación pública por tipo y slug
 */
export const getPublicEntry = async (kind: 'showcase' | 'post' | 'legal',
    slug: string, options?: Parameters<typeof customFetch>[1]): Promise<PublicEntry> => {

  return customFetch<PublicEntry>(getGetPublicEntryUrl(kind,slug),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetPublicEntryQueryKey = (kind: 'showcase' | 'post' | 'legal',
    slug: string,) => {
    return [
    `/api/public/entries/${kind}/${slug}`
    ] as const;
    }


export const getGetPublicEntryQueryOptions = <TData = Awaited<ReturnType<typeof getPublicEntry>>, TError = ErrorType<void>>(kind: 'showcase' | 'post' | 'legal',
    slug: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getPublicEntry>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
) => {

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

  const queryKey =  queryOptions?.queryKey ?? getGetPublicEntryQueryKey(kind,slug);



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





   return  { queryKey, queryFn, enabled: kind !== null && kind !== undefined && slug !== null && slug !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getPublicEntry>>, TError, TData> & { queryKey: QueryKey }
}

export type GetPublicEntryQueryResult = NonNullable<Awaited<ReturnType<typeof getPublicEntry>>>
export type GetPublicEntryQueryError = ErrorType<void>


/**
 * @summary Obtiene una publicación pública por tipo y slug
 */

export function useGetPublicEntry<TData = Awaited<ReturnType<typeof getPublicEntry>>, TError = ErrorType<void>>(
 kind: 'showcase' | 'post' | 'legal',
    slug: string, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof getPublicEntry>>, TError, TData>, request?: SecondParameter<typeof customFetch>}

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

  const queryOptions = getGetPublicEntryQueryOptions(kind,slug,options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateQuoteRequestUrl = () => {




  return `/api/public/quotes`
}

/**
 * @summary Envía una solicitud de cotización
 */
export const createQuoteRequest = async (quoteInput: QuoteInput, options?: Parameters<typeof customFetch>[1]): Promise<Quote> => {

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





export const getCreateQuoteRequestMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createQuoteRequest>>, TError,{data: BodyType<QuoteInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createQuoteRequest>>, TError,{data: BodyType<QuoteInput>}, TContext> => {

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

          return  createQuoteRequest(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateQuoteRequestMutationResult = NonNullable<Awaited<ReturnType<typeof createQuoteRequest>>>
    export type CreateQuoteRequestMutationBody = BodyType<QuoteInput>
    export type CreateQuoteRequestMutationError = ErrorType<unknown>

    /**
 * @summary Envía una solicitud de cotización
 */
export const useCreateQuoteRequest = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createQuoteRequest>>, TError,{data: BodyType<QuoteInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createQuoteRequest>>,
        TError,
        {data: BodyType<QuoteInput>},
        TContext
      > => {
      return useMutation(getCreateQuoteRequestMutationOptions(options));
    }

export const getCreateContactMessageUrl = () => {




  return `/api/public/contact`
}

/**
 * @summary Envía un mensaje de contacto
 */
export const createContactMessage = async (contactInput: ContactInput, options?: Parameters<typeof customFetch>[1]): Promise<LeadReceipt> => {

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





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

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

          return  createContactMessage(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateContactMessageMutationResult = NonNullable<Awaited<ReturnType<typeof createContactMessage>>>
    export type CreateContactMessageMutationBody = BodyType<ContactInput>
    export type CreateContactMessageMutationError = ErrorType<unknown>

    /**
 * @summary Envía un mensaje de contacto
 */
export const useCreateContactMessage = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createContactMessage>>, TError,{data: BodyType<ContactInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createContactMessage>>,
        TError,
        {data: BodyType<ContactInput>},
        TContext
      > => {
      return useMutation(getCreateContactMessageMutationOptions(options));
    }

export const getGetCurrentUserUrl = () => {




  return `/api/auth/me`
}

/**
 * @summary Devuelve el usuario administrativo actual
 */
export const getCurrentUser = async ( options?: Parameters<typeof customFetch>[1]): Promise<CurrentUser | MobileUser> => {

  return customFetch<CurrentUser | MobileUser>(getGetCurrentUserUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetCurrentUserQueryKey = () => {
    return [
    `/api/auth/me`
    ] as const;
    }


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

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

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



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





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

export type GetCurrentUserQueryResult = NonNullable<Awaited<ReturnType<typeof getCurrentUser>>>
export type GetCurrentUserQueryError = ErrorType<unknown>


/**
 * @summary Devuelve el usuario administrativo actual
 */

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

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

  const queryOptions = getGetCurrentUserQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getLoginUrl = () => {




  return `/api/auth/login`
}

/**
 * @summary Inicia una sesión web o móvil
 */
export const login = async (loginInput: LoginInput, options?: Parameters<typeof customFetch>[1]): Promise<AuthLoginResponse | AuthSecondFactorRequiredResponse> => {

  return customFetch<AuthLoginResponse | AuthSecondFactorRequiredResponse>(getLoginUrl(),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(loginInput)
  }
);}





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

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

          return  login(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type LoginMutationResult = NonNullable<Awaited<ReturnType<typeof login>>>
    export type LoginMutationBody = BodyType<LoginInput>
    export type LoginMutationError = ErrorType<void>

    /**
 * @summary Inicia una sesión web o móvil
 */
export const useLogin = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof login>>, TError,{data: BodyType<LoginInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof login>>,
        TError,
        {data: BodyType<LoginInput>},
        TContext
      > => {
      return useMutation(getLoginMutationOptions(options));
    }

export const getIssueAdminSecondFactorDailyCodeUrl = () => {




  return `/api/auth/second-factor/daily-code`
}

/**
 * El código se muestra una sola vez, se almacena únicamente como hash y expira al finalizar el día UTC.
 * @summary Emite el código diario del usuario administrativo actual
 */
export const issueAdminSecondFactorDailyCode = async ( options?: Parameters<typeof customFetch>[1]): Promise<AdminSecondFactorCodeIssued> => {

  return customFetch<AdminSecondFactorCodeIssued>(getIssueAdminSecondFactorDailyCodeUrl(),
  {
    ...options,
    method: 'POST'


  }
);}





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

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


          return  issueAdminSecondFactorDailyCode(requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type IssueAdminSecondFactorDailyCodeMutationResult = NonNullable<Awaited<ReturnType<typeof issueAdminSecondFactorDailyCode>>>

    export type IssueAdminSecondFactorDailyCodeMutationError = ErrorType<void>

    /**
 * @summary Emite el código diario del usuario administrativo actual
 */
export const useIssueAdminSecondFactorDailyCode = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof issueAdminSecondFactorDailyCode>>, TError,void, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof issueAdminSecondFactorDailyCode>>,
        TError,
        void,
        TContext
      > => {
      return useMutation(getIssueAdminSecondFactorDailyCodeMutationOptions(options));
    }

export const getMobileCodeLoginUrl = () => {




  return `/api/auth/mobile/login`
}

/**
 * El código de empleado es una credencial secreta emitida y revocada únicamente por personal autorizado. No acepta correo ni número de seguro social.
 * @summary Inicia sesión móvil con código corporativo
 */
export const mobileCodeLogin = async (mobileLoginInput: MobileLoginInput, options?: Parameters<typeof customFetch>[1]): Promise<MobileLoginResponse> => {

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





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

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

          return  mobileCodeLogin(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type MobileCodeLoginMutationResult = NonNullable<Awaited<ReturnType<typeof mobileCodeLogin>>>
    export type MobileCodeLoginMutationBody = BodyType<MobileLoginInput>
    export type MobileCodeLoginMutationError = ErrorType<void>

    /**
 * @summary Inicia sesión móvil con código corporativo
 */
export const useMobileCodeLogin = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof mobileCodeLogin>>, TError,{data: BodyType<MobileLoginInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof mobileCodeLogin>>,
        TError,
        {data: BodyType<MobileLoginInput>},
        TContext
      > => {
      return useMutation(getMobileCodeLoginMutationOptions(options));
    }

export const getLogoutUrl = () => {




  return `/api/auth/logout`
}

/**
 * @summary Revoca la sesión actual
 */
export const logout = async ( options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getLogoutUrl(),
  {
    ...options,
    method: 'POST'


  }
);}





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

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


          return  logout(requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type LogoutMutationResult = NonNullable<Awaited<ReturnType<typeof logout>>>

    export type LogoutMutationError = ErrorType<unknown>

    /**
 * @summary Revoca la sesión actual
 */
export const useLogout = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError,void, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof logout>>,
        TError,
        void,
        TContext
      > => {
      return useMutation(getLogoutMutationOptions(options));
    }

export const getGetCsrfTokenUrl = () => {




  return `/api/auth/csrf`
}

/**
 * @summary Obtiene el token CSRF de la sesión web
 */
export const getCsrfToken = async ( options?: Parameters<typeof customFetch>[1]): Promise<CsrfResponse> => {

  return customFetch<CsrfResponse>(getGetCsrfTokenUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetCsrfTokenQueryKey = () => {
    return [
    `/api/auth/csrf`
    ] as const;
    }


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

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

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



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





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

export type GetCsrfTokenQueryResult = NonNullable<Awaited<ReturnType<typeof getCsrfToken>>>
export type GetCsrfTokenQueryError = ErrorType<unknown>


/**
 * @summary Obtiene el token CSRF de la sesión web
 */

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

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

  const queryOptions = getGetCsrfTokenQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getStartImpersonationUrl = () => {




  return `/api/auth/impersonation`
}

/**
 * Solo Web Master o super_admin. La sesión devuelta es independiente de la sesión administrativa y expira en 30 minutos.
 * @summary Abre una sesión delegada de un empleado
 */
export const startImpersonation = async (startImpersonationInput: StartImpersonationInput, options?: Parameters<typeof customFetch>[1]): Promise<ImpersonationSession> => {

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





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

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

          return  startImpersonation(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type StartImpersonationMutationResult = NonNullable<Awaited<ReturnType<typeof startImpersonation>>>
    export type StartImpersonationMutationBody = BodyType<StartImpersonationInput>
    export type StartImpersonationMutationError = ErrorType<void>

    /**
 * @summary Abre una sesión delegada de un empleado
 */
export const useStartImpersonation = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof startImpersonation>>, TError,{data: BodyType<StartImpersonationInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof startImpersonation>>,
        TError,
        {data: BodyType<StartImpersonationInput>},
        TContext
      > => {
      return useMutation(getStartImpersonationMutationOptions(options));
    }

export const getEndImpersonationUrl = () => {




  return `/api/auth/impersonation/end`
}

/**
 * @summary Cierra la sesión delegada actual
 */
export const endImpersonation = async ( options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getEndImpersonationUrl(),
  {
    ...options,
    method: 'POST'


  }
);}





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

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


          return  endImpersonation(requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type EndImpersonationMutationResult = NonNullable<Awaited<ReturnType<typeof endImpersonation>>>

    export type EndImpersonationMutationError = ErrorType<unknown>

    /**
 * @summary Cierra la sesión delegada actual
 */
export const useEndImpersonation = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof endImpersonation>>, TError,void, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof endImpersonation>>,
        TError,
        void,
        TContext
      > => {
      return useMutation(getEndImpersonationMutationOptions(options));
    }

export const getGetSupervisorSummaryUrl = () => {




  return `/api/supervisor/summary`
}

/**
 * Devuelve únicamente obras, trabajadores, asistencia, alertas y solicitudes asignadas al supervisor autenticado.
 * @summary Resumen acotado de la operación asignada
 */
export const getSupervisorSummary = async ( options?: Parameters<typeof customFetch>[1]): Promise<SupervisorSummary> => {

  return customFetch<SupervisorSummary>(getGetSupervisorSummaryUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetSupervisorSummaryQueryKey = () => {
    return [
    `/api/supervisor/summary`
    ] as const;
    }


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

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

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



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





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

export type GetSupervisorSummaryQueryResult = NonNullable<Awaited<ReturnType<typeof getSupervisorSummary>>>
export type GetSupervisorSummaryQueryError = ErrorType<void>


/**
 * @summary Resumen acotado de la operación asignada
 */

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

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

  const queryOptions = getGetSupervisorSummaryQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCorrectSupervisorAttendanceUrl = (id: string,) => {




  return `/api/supervisor/attendance/${id}`
}

/**
 * @summary Corrige una marcación del equipo asignado
 */
export const correctSupervisorAttendance = async (id: string,
    supervisorAttendanceCorrection: SupervisorAttendanceCorrection, options?: Parameters<typeof customFetch>[1]): Promise<AttendanceRecord> => {

  return customFetch<AttendanceRecord>(getCorrectSupervisorAttendanceUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(supervisorAttendanceCorrection)
  }
);}





export const getCorrectSupervisorAttendanceMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof correctSupervisorAttendance>>, TError,{id: string;data: BodyType<SupervisorAttendanceCorrection>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof correctSupervisorAttendance>>, TError,{id: string;data: BodyType<SupervisorAttendanceCorrection>}, TContext> => {

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

          return  correctSupervisorAttendance(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CorrectSupervisorAttendanceMutationResult = NonNullable<Awaited<ReturnType<typeof correctSupervisorAttendance>>>
    export type CorrectSupervisorAttendanceMutationBody = BodyType<SupervisorAttendanceCorrection>
    export type CorrectSupervisorAttendanceMutationError = ErrorType<void>

    /**
 * @summary Corrige una marcación del equipo asignado
 */
export const useCorrectSupervisorAttendance = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof correctSupervisorAttendance>>, TError,{id: string;data: BodyType<SupervisorAttendanceCorrection>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof correctSupervisorAttendance>>,
        TError,
        {id: string;data: BodyType<SupervisorAttendanceCorrection>},
        TContext
      > => {
      return useMutation(getCorrectSupervisorAttendanceMutationOptions(options));
    }

export const getReviewSupervisorLeaveRequestUrl = (id: string,) => {




  return `/api/supervisor/leave-requests/${id}`
}

/**
 * @summary Aprueba o deniega una solicitud del equipo asignado
 */
export const reviewSupervisorLeaveRequest = async (id: string,
    supervisorLeaveReview: SupervisorLeaveReview, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getReviewSupervisorLeaveRequestUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(supervisorLeaveReview)
  }
);}





export const getReviewSupervisorLeaveRequestMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof reviewSupervisorLeaveRequest>>, TError,{id: string;data: BodyType<SupervisorLeaveReview>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof reviewSupervisorLeaveRequest>>, TError,{id: string;data: BodyType<SupervisorLeaveReview>}, TContext> => {

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

          return  reviewSupervisorLeaveRequest(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type ReviewSupervisorLeaveRequestMutationResult = NonNullable<Awaited<ReturnType<typeof reviewSupervisorLeaveRequest>>>
    export type ReviewSupervisorLeaveRequestMutationBody = BodyType<SupervisorLeaveReview>
    export type ReviewSupervisorLeaveRequestMutationError = ErrorType<void>

    /**
 * @summary Aprueba o deniega una solicitud del equipo asignado
 */
export const useReviewSupervisorLeaveRequest = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof reviewSupervisorLeaveRequest>>, TError,{id: string;data: BodyType<SupervisorLeaveReview>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof reviewSupervisorLeaveRequest>>,
        TError,
        {id: string;data: BodyType<SupervisorLeaveReview>},
        TContext
      > => {
      return useMutation(getReviewSupervisorLeaveRequestMutationOptions(options));
    }

export const getGetDashboardSummaryUrl = () => {




  return `/api/dashboard/summary`
}

/**
 * @summary Resumen de indicadores operativos
 */
export const getDashboardSummary = async ( options?: Parameters<typeof customFetch>[1]): Promise<DashboardSummary> => {

  return customFetch<DashboardSummary>(getGetDashboardSummaryUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetDashboardSummaryQueryKey = () => {
    return [
    `/api/dashboard/summary`
    ] as const;
    }


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

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

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



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





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

export type GetDashboardSummaryQueryResult = NonNullable<Awaited<ReturnType<typeof getDashboardSummary>>>
export type GetDashboardSummaryQueryError = ErrorType<unknown>


/**
 * @summary Resumen de indicadores operativos
 */

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

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

  const queryOptions = getGetDashboardSummaryQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListActivityUrl = () => {




  return `/api/dashboard/activity`
}

/**
 * @summary Actividad reciente
 */
export const listActivity = async ( options?: Parameters<typeof customFetch>[1]): Promise<ActivityItem[]> => {

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


  }
);}





export const getListActivityQueryKey = () => {
    return [
    `/api/dashboard/activity`
    ] as const;
    }


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

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

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



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





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

export type ListActivityQueryResult = NonNullable<Awaited<ReturnType<typeof listActivity>>>
export type ListActivityQueryError = ErrorType<unknown>


/**
 * @summary Actividad reciente
 */

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

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

  const queryOptions = getListActivityQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListQuotesUrl = () => {




  return `/api/quotes`
}

/**
 * @summary Lista solicitudes de cotización
 */
export const listQuotes = async ( options?: Parameters<typeof customFetch>[1]): Promise<Quote[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListQuotesQueryResult = NonNullable<Awaited<ReturnType<typeof listQuotes>>>
export type ListQuotesQueryError = ErrorType<unknown>


/**
 * @summary Lista solicitudes de cotización
 */

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

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

  const queryOptions = getListQuotesQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateQuoteUrl = () => {




  return `/api/quotes`
}

/**
 * @summary Crea una cotización interna
 */
export const createQuote = async (quoteInput: QuoteInput, options?: Parameters<typeof customFetch>[1]): Promise<Quote> => {

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





export const getCreateQuoteMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createQuote>>, TError,{data: BodyType<QuoteInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createQuote>>, TError,{data: BodyType<QuoteInput>}, TContext> => {

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

          return  createQuote(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateQuoteMutationResult = NonNullable<Awaited<ReturnType<typeof createQuote>>>
    export type CreateQuoteMutationBody = BodyType<QuoteInput>
    export type CreateQuoteMutationError = ErrorType<unknown>

    /**
 * @summary Crea una cotización interna
 */
export const useCreateQuote = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createQuote>>, TError,{data: BodyType<QuoteInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createQuote>>,
        TError,
        {data: BodyType<QuoteInput>},
        TContext
      > => {
      return useMutation(getCreateQuoteMutationOptions(options));
    }

export const getGetQuoteUrl = (id: string,) => {




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

/**
 * @summary Obtiene una cotización
 */
export const getQuote = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<Quote> => {

  return customFetch<Quote>(getGetQuoteUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetQuoteQueryKey = (id: string,) => {
    return [
    `/api/quotes/${id}`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getQuote>>, TError, TData> & { queryKey: QueryKey }
}

export type GetQuoteQueryResult = NonNullable<Awaited<ReturnType<typeof getQuote>>>
export type GetQuoteQueryError = ErrorType<unknown>


/**
 * @summary Obtiene una cotización
 */

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

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

  const queryOptions = getGetQuoteQueryOptions(id,options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getUpdateQuoteUrl = (id: string,) => {




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

/**
 * @summary Actualiza una cotización
 */
export const updateQuote = async (id: string,
    quoteUpdate: QuoteUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Quote> => {

  return customFetch<Quote>(getUpdateQuoteUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(quoteUpdate)
  }
);}





export const getUpdateQuoteMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateQuote>>, TError,{id: string;data: BodyType<QuoteUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateQuote>>, TError,{id: string;data: BodyType<QuoteUpdate>}, TContext> => {

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

          return  updateQuote(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateQuoteMutationResult = NonNullable<Awaited<ReturnType<typeof updateQuote>>>
    export type UpdateQuoteMutationBody = BodyType<QuoteUpdate>
    export type UpdateQuoteMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza una cotización
 */
export const useUpdateQuote = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateQuote>>, TError,{id: string;data: BodyType<QuoteUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateQuote>>,
        TError,
        {id: string;data: BodyType<QuoteUpdate>},
        TContext
      > => {
      return useMutation(getUpdateQuoteMutationOptions(options));
    }

export const getDeleteQuoteUrl = (id: string,) => {




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

/**
 * @summary Elimina una cotización
 */
export const deleteQuote = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteQuoteUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteQuoteMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteQuote>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteQuote>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteQuote'];
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 deleteQuote>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteQuote(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteQuoteMutationResult = NonNullable<Awaited<ReturnType<typeof deleteQuote>>>

    export type DeleteQuoteMutationError = ErrorType<unknown>

    /**
 * @summary Elimina una cotización
 */
export const useDeleteQuote = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteQuote>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteQuote>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteQuoteMutationOptions(options));
    }

export const getListClientsUrl = () => {




  return `/api/clients`
}

/**
 * @summary Lista clientes
 */
export const listClients = async ( options?: Parameters<typeof customFetch>[1]): Promise<Client[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListClientsQueryResult = NonNullable<Awaited<ReturnType<typeof listClients>>>
export type ListClientsQueryError = ErrorType<unknown>


/**
 * @summary Lista clientes
 */

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

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

  const queryOptions = getListClientsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateClientUrl = () => {




  return `/api/clients`
}

/**
 * @summary Crea un cliente
 */
export const createClient = async (clientInput: ClientInput, options?: Parameters<typeof customFetch>[1]): Promise<Client> => {

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





export const getCreateClientMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createClient>>, TError,{data: BodyType<ClientInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createClient>>, TError,{data: BodyType<ClientInput>}, TContext> => {

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

          return  createClient(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateClientMutationResult = NonNullable<Awaited<ReturnType<typeof createClient>>>
    export type CreateClientMutationBody = BodyType<ClientInput>
    export type CreateClientMutationError = ErrorType<unknown>

    /**
 * @summary Crea un cliente
 */
export const useCreateClient = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createClient>>, TError,{data: BodyType<ClientInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createClient>>,
        TError,
        {data: BodyType<ClientInput>},
        TContext
      > => {
      return useMutation(getCreateClientMutationOptions(options));
    }

export const getUpdateClientUrl = (id: string,) => {




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

/**
 * @summary Actualiza un cliente
 */
export const updateClient = async (id: string,
    clientUpdate: ClientUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Client> => {

  return customFetch<Client>(getUpdateClientUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(clientUpdate)
  }
);}





export const getUpdateClientMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateClient>>, TError,{id: string;data: BodyType<ClientUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateClient>>, TError,{id: string;data: BodyType<ClientUpdate>}, TContext> => {

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

          return  updateClient(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateClientMutationResult = NonNullable<Awaited<ReturnType<typeof updateClient>>>
    export type UpdateClientMutationBody = BodyType<ClientUpdate>
    export type UpdateClientMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza un cliente
 */
export const useUpdateClient = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateClient>>, TError,{id: string;data: BodyType<ClientUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateClient>>,
        TError,
        {id: string;data: BodyType<ClientUpdate>},
        TContext
      > => {
      return useMutation(getUpdateClientMutationOptions(options));
    }

export const getDeleteClientUrl = (id: string,) => {




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

/**
 * @summary Elimina un cliente
 */
export const deleteClient = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteClientUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteClientMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteClient>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteClient>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteClient'];
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 deleteClient>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteClient(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteClientMutationResult = NonNullable<Awaited<ReturnType<typeof deleteClient>>>

    export type DeleteClientMutationError = ErrorType<unknown>

    /**
 * @summary Elimina un cliente
 */
export const useDeleteClient = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteClient>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteClient>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteClientMutationOptions(options));
    }

export const getListProjectsUrl = () => {




  return `/api/projects`
}

/**
 * @summary Lista proyectos
 */
export const listProjects = async ( options?: Parameters<typeof customFetch>[1]): Promise<Project[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListProjectsQueryResult = NonNullable<Awaited<ReturnType<typeof listProjects>>>
export type ListProjectsQueryError = ErrorType<unknown>


/**
 * @summary Lista proyectos
 */

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

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

  const queryOptions = getListProjectsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateProjectUrl = () => {




  return `/api/projects`
}

/**
 * @summary Crea un proyecto
 */
export const createProject = async (projectInput: ProjectInput, options?: Parameters<typeof customFetch>[1]): Promise<Project> => {

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





export const getCreateProjectMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createProject>>, TError,{data: BodyType<ProjectInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createProject>>, TError,{data: BodyType<ProjectInput>}, TContext> => {

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

          return  createProject(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateProjectMutationResult = NonNullable<Awaited<ReturnType<typeof createProject>>>
    export type CreateProjectMutationBody = BodyType<ProjectInput>
    export type CreateProjectMutationError = ErrorType<unknown>

    /**
 * @summary Crea un proyecto
 */
export const useCreateProject = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createProject>>, TError,{data: BodyType<ProjectInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createProject>>,
        TError,
        {data: BodyType<ProjectInput>},
        TContext
      > => {
      return useMutation(getCreateProjectMutationOptions(options));
    }

export const getGetProjectUrl = (id: string,) => {




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

/**
 * @summary Detalle de proyecto
 */
export const getProject = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<ProjectDetail> => {

  return customFetch<ProjectDetail>(getGetProjectUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetProjectQueryKey = (id: string,) => {
    return [
    `/api/projects/${id}`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getProject>>, TError, TData> & { queryKey: QueryKey }
}

export type GetProjectQueryResult = NonNullable<Awaited<ReturnType<typeof getProject>>>
export type GetProjectQueryError = ErrorType<unknown>


/**
 * @summary Detalle de proyecto
 */

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

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

  const queryOptions = getGetProjectQueryOptions(id,options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getUpdateProjectUrl = (id: string,) => {




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

/**
 * @summary Actualiza un proyecto
 */
export const updateProject = async (id: string,
    projectUpdate: ProjectUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Project> => {

  return customFetch<Project>(getUpdateProjectUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(projectUpdate)
  }
);}





export const getUpdateProjectMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateProject>>, TError,{id: string;data: BodyType<ProjectUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateProject>>, TError,{id: string;data: BodyType<ProjectUpdate>}, TContext> => {

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

          return  updateProject(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateProjectMutationResult = NonNullable<Awaited<ReturnType<typeof updateProject>>>
    export type UpdateProjectMutationBody = BodyType<ProjectUpdate>
    export type UpdateProjectMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza un proyecto
 */
export const useUpdateProject = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateProject>>, TError,{id: string;data: BodyType<ProjectUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateProject>>,
        TError,
        {id: string;data: BodyType<ProjectUpdate>},
        TContext
      > => {
      return useMutation(getUpdateProjectMutationOptions(options));
    }

export const getDeleteProjectUrl = (id: string,) => {




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

/**
 * @summary Elimina un proyecto
 */
export const deleteProject = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteProjectUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteProjectMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteProject>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteProject>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteProject'];
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 deleteProject>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteProject(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteProjectMutationResult = NonNullable<Awaited<ReturnType<typeof deleteProject>>>

    export type DeleteProjectMutationError = ErrorType<unknown>

    /**
 * @summary Elimina un proyecto
 */
export const useDeleteProject = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteProject>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteProject>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteProjectMutationOptions(options));
    }

export const getListWorksitesUrl = () => {




  return `/api/worksites`
}

/**
 * @summary Lista obras
 */
export const listWorksites = async ( options?: Parameters<typeof customFetch>[1]): Promise<Worksite[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListWorksitesQueryResult = NonNullable<Awaited<ReturnType<typeof listWorksites>>>
export type ListWorksitesQueryError = ErrorType<unknown>


/**
 * @summary Lista obras
 */

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

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

  const queryOptions = getListWorksitesQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateWorksiteUrl = () => {




  return `/api/worksites`
}

/**
 * @summary Crea una obra
 */
export const createWorksite = async (worksiteInput: WorksiteInput, options?: Parameters<typeof customFetch>[1]): Promise<Worksite> => {

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





export const getCreateWorksiteMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createWorksite>>, TError,{data: BodyType<WorksiteInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createWorksite>>, TError,{data: BodyType<WorksiteInput>}, TContext> => {

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

          return  createWorksite(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateWorksiteMutationResult = NonNullable<Awaited<ReturnType<typeof createWorksite>>>
    export type CreateWorksiteMutationBody = BodyType<WorksiteInput>
    export type CreateWorksiteMutationError = ErrorType<unknown>

    /**
 * @summary Crea una obra
 */
export const useCreateWorksite = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createWorksite>>, TError,{data: BodyType<WorksiteInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createWorksite>>,
        TError,
        {data: BodyType<WorksiteInput>},
        TContext
      > => {
      return useMutation(getCreateWorksiteMutationOptions(options));
    }

export const getUpdateWorksiteUrl = (id: string,) => {




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

/**
 * @summary Actualiza una obra
 */
export const updateWorksite = async (id: string,
    worksiteUpdate: WorksiteUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Worksite> => {

  return customFetch<Worksite>(getUpdateWorksiteUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(worksiteUpdate)
  }
);}





export const getUpdateWorksiteMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateWorksite>>, TError,{id: string;data: BodyType<WorksiteUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateWorksite>>, TError,{id: string;data: BodyType<WorksiteUpdate>}, TContext> => {

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

          return  updateWorksite(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateWorksiteMutationResult = NonNullable<Awaited<ReturnType<typeof updateWorksite>>>
    export type UpdateWorksiteMutationBody = BodyType<WorksiteUpdate>
    export type UpdateWorksiteMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza una obra
 */
export const useUpdateWorksite = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateWorksite>>, TError,{id: string;data: BodyType<WorksiteUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateWorksite>>,
        TError,
        {id: string;data: BodyType<WorksiteUpdate>},
        TContext
      > => {
      return useMutation(getUpdateWorksiteMutationOptions(options));
    }

export const getDeleteWorksiteUrl = (id: string,) => {




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

/**
 * @summary Elimina una obra
 */
export const deleteWorksite = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteWorksiteUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteWorksiteMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteWorksite>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteWorksite>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteWorksite'];
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 deleteWorksite>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteWorksite(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteWorksiteMutationResult = NonNullable<Awaited<ReturnType<typeof deleteWorksite>>>

    export type DeleteWorksiteMutationError = ErrorType<unknown>

    /**
 * @summary Elimina una obra
 */
export const useDeleteWorksite = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteWorksite>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteWorksite>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteWorksiteMutationOptions(options));
    }

export const getListEquipmentUrl = () => {




  return `/api/equipment`
}

/**
 * @summary Lista maquinaria y equipo
 */
export const listEquipment = async ( options?: Parameters<typeof customFetch>[1]): Promise<Equipment[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListEquipmentQueryResult = NonNullable<Awaited<ReturnType<typeof listEquipment>>>
export type ListEquipmentQueryError = ErrorType<unknown>


/**
 * @summary Lista maquinaria y equipo
 */

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

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

  const queryOptions = getListEquipmentQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateEquipmentUrl = () => {




  return `/api/equipment`
}

/**
 * @summary Registra maquinaria
 */
export const createEquipment = async (equipmentInput: EquipmentInput, options?: Parameters<typeof customFetch>[1]): Promise<Equipment> => {

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





export const getCreateEquipmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createEquipment>>, TError,{data: BodyType<EquipmentInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createEquipment>>, TError,{data: BodyType<EquipmentInput>}, TContext> => {

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

          return  createEquipment(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateEquipmentMutationResult = NonNullable<Awaited<ReturnType<typeof createEquipment>>>
    export type CreateEquipmentMutationBody = BodyType<EquipmentInput>
    export type CreateEquipmentMutationError = ErrorType<unknown>

    /**
 * @summary Registra maquinaria
 */
export const useCreateEquipment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createEquipment>>, TError,{data: BodyType<EquipmentInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createEquipment>>,
        TError,
        {data: BodyType<EquipmentInput>},
        TContext
      > => {
      return useMutation(getCreateEquipmentMutationOptions(options));
    }

export const getUpdateEquipmentUrl = (id: string,) => {




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

/**
 * @summary Actualiza maquinaria
 */
export const updateEquipment = async (id: string,
    equipmentUpdate: EquipmentUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Equipment> => {

  return customFetch<Equipment>(getUpdateEquipmentUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(equipmentUpdate)
  }
);}





export const getUpdateEquipmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateEquipment>>, TError,{id: string;data: BodyType<EquipmentUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateEquipment>>, TError,{id: string;data: BodyType<EquipmentUpdate>}, TContext> => {

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

          return  updateEquipment(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateEquipmentMutationResult = NonNullable<Awaited<ReturnType<typeof updateEquipment>>>
    export type UpdateEquipmentMutationBody = BodyType<EquipmentUpdate>
    export type UpdateEquipmentMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza maquinaria
 */
export const useUpdateEquipment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateEquipment>>, TError,{id: string;data: BodyType<EquipmentUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateEquipment>>,
        TError,
        {id: string;data: BodyType<EquipmentUpdate>},
        TContext
      > => {
      return useMutation(getUpdateEquipmentMutationOptions(options));
    }

export const getDeleteEquipmentUrl = (id: string,) => {




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

/**
 * @summary Retira maquinaria del catálogo
 */
export const deleteEquipment = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteEquipmentUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteEquipmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteEquipment>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteEquipment>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteEquipment'];
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 deleteEquipment>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteEquipment(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteEquipmentMutationResult = NonNullable<Awaited<ReturnType<typeof deleteEquipment>>>

    export type DeleteEquipmentMutationError = ErrorType<unknown>

    /**
 * @summary Retira maquinaria del catálogo
 */
export const useDeleteEquipment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteEquipment>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteEquipment>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteEquipmentMutationOptions(options));
    }

export const getListMaterialsUrl = () => {




  return `/api/materials`
}

/**
 * @summary Lista materiales
 */
export const listMaterials = async ( options?: Parameters<typeof customFetch>[1]): Promise<Material[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListMaterialsQueryResult = NonNullable<Awaited<ReturnType<typeof listMaterials>>>
export type ListMaterialsQueryError = ErrorType<unknown>


/**
 * @summary Lista materiales
 */

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

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

  const queryOptions = getListMaterialsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateMaterialUrl = () => {




  return `/api/materials`
}

/**
 * @summary Registra material
 */
export const createMaterial = async (materialInput: MaterialInput, options?: Parameters<typeof customFetch>[1]): Promise<Material> => {

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





export const getCreateMaterialMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createMaterial>>, TError,{data: BodyType<MaterialInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createMaterial>>, TError,{data: BodyType<MaterialInput>}, TContext> => {

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

          return  createMaterial(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateMaterialMutationResult = NonNullable<Awaited<ReturnType<typeof createMaterial>>>
    export type CreateMaterialMutationBody = BodyType<MaterialInput>
    export type CreateMaterialMutationError = ErrorType<unknown>

    /**
 * @summary Registra material
 */
export const useCreateMaterial = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createMaterial>>, TError,{data: BodyType<MaterialInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createMaterial>>,
        TError,
        {data: BodyType<MaterialInput>},
        TContext
      > => {
      return useMutation(getCreateMaterialMutationOptions(options));
    }

export const getUpdateMaterialUrl = (id: string,) => {




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

/**
 * @summary Actualiza material
 */
export const updateMaterial = async (id: string,
    materialUpdate: MaterialUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Material> => {

  return customFetch<Material>(getUpdateMaterialUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(materialUpdate)
  }
);}





export const getUpdateMaterialMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateMaterial>>, TError,{id: string;data: BodyType<MaterialUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateMaterial>>, TError,{id: string;data: BodyType<MaterialUpdate>}, TContext> => {

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

          return  updateMaterial(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateMaterialMutationResult = NonNullable<Awaited<ReturnType<typeof updateMaterial>>>
    export type UpdateMaterialMutationBody = BodyType<MaterialUpdate>
    export type UpdateMaterialMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza material
 */
export const useUpdateMaterial = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateMaterial>>, TError,{id: string;data: BodyType<MaterialUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateMaterial>>,
        TError,
        {id: string;data: BodyType<MaterialUpdate>},
        TContext
      > => {
      return useMutation(getUpdateMaterialMutationOptions(options));
    }

export const getDeleteMaterialUrl = (id: string,) => {




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

/**
 * @summary Retira material
 */
export const deleteMaterial = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteMaterialUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteMaterialMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteMaterial>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteMaterial>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteMaterial'];
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 deleteMaterial>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteMaterial(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteMaterialMutationResult = NonNullable<Awaited<ReturnType<typeof deleteMaterial>>>

    export type DeleteMaterialMutationError = ErrorType<unknown>

    /**
 * @summary Retira material
 */
export const useDeleteMaterial = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteMaterial>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteMaterial>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteMaterialMutationOptions(options));
    }

export const getListEmployeesUrl = (params?: ListEmployeesParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {

    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value))
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0 ? `/api/employees?${stringifiedParams}` : `/api/employees`
}

/**
 * @summary Lista empleados y supervisores
 */
export const listEmployees = async (params?: ListEmployeesParams, options?: Parameters<typeof customFetch>[1]): Promise<Employee[]> => {

  return customFetch<Employee[]>(getListEmployeesUrl(params),
  {
    ...options,
    method: 'GET'


  }
);}





export const getListEmployeesQueryKey = (params?: ListEmployeesParams,) => {
    return [
    `/api/employees`, ...(params ? [params] : [])
    ] as const;
    }


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

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

  const queryKey =  queryOptions?.queryKey ?? getListEmployeesQueryKey(params);



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





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

export type ListEmployeesQueryResult = NonNullable<Awaited<ReturnType<typeof listEmployees>>>
export type ListEmployeesQueryError = ErrorType<unknown>


/**
 * @summary Lista empleados y supervisores
 */

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

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

  const queryOptions = getListEmployeesQueryOptions(params,options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateEmployeeUrl = () => {




  return `/api/employees`
}

/**
 * @summary Crea un empleado
 */
export const createEmployee = async (employeeInput: EmployeeInput, options?: Parameters<typeof customFetch>[1]): Promise<Employee> => {

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





export const getCreateEmployeeMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createEmployee>>, TError,{data: BodyType<EmployeeInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createEmployee>>, TError,{data: BodyType<EmployeeInput>}, TContext> => {

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

          return  createEmployee(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateEmployeeMutationResult = NonNullable<Awaited<ReturnType<typeof createEmployee>>>
    export type CreateEmployeeMutationBody = BodyType<EmployeeInput>
    export type CreateEmployeeMutationError = ErrorType<unknown>

    /**
 * @summary Crea un empleado
 */
export const useCreateEmployee = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createEmployee>>, TError,{data: BodyType<EmployeeInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createEmployee>>,
        TError,
        {data: BodyType<EmployeeInput>},
        TContext
      > => {
      return useMutation(getCreateEmployeeMutationOptions(options));
    }

export const getUpdateEmployeeUrl = (id: string,) => {




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

/**
 * @summary Actualiza un empleado
 */
export const updateEmployee = async (id: string,
    employeeUpdate: EmployeeUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Employee> => {

  return customFetch<Employee>(getUpdateEmployeeUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(employeeUpdate)
  }
);}





export const getUpdateEmployeeMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateEmployee>>, TError,{id: string;data: BodyType<EmployeeUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateEmployee>>, TError,{id: string;data: BodyType<EmployeeUpdate>}, TContext> => {

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

          return  updateEmployee(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateEmployeeMutationResult = NonNullable<Awaited<ReturnType<typeof updateEmployee>>>
    export type UpdateEmployeeMutationBody = BodyType<EmployeeUpdate>
    export type UpdateEmployeeMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza un empleado
 */
export const useUpdateEmployee = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateEmployee>>, TError,{id: string;data: BodyType<EmployeeUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateEmployee>>,
        TError,
        {id: string;data: BodyType<EmployeeUpdate>},
        TContext
      > => {
      return useMutation(getUpdateEmployeeMutationOptions(options));
    }

export const getDeleteEmployeeUrl = (id: string,) => {




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

/**
 * @summary Desactiva un empleado
 */
export const deleteEmployee = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteEmployeeUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteEmployeeMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteEmployee>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteEmployee>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteEmployee'];
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 deleteEmployee>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteEmployee(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteEmployeeMutationResult = NonNullable<Awaited<ReturnType<typeof deleteEmployee>>>

    export type DeleteEmployeeMutationError = ErrorType<unknown>

    /**
 * @summary Desactiva un empleado
 */
export const useDeleteEmployee = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteEmployee>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteEmployee>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteEmployeeMutationOptions(options));
    }

export const getIssueEmployeeMobileCredentialUrl = (id: string,) => {




  return `/api/employees/${id}/mobile-credential`
}

/**
 * Solo Web Master, administración o RR. HH. autorizado. Los secretos sin hash se muestran una sola vez.
 * @summary Emite o rota una credencial móvil de empleado
 */
export const issueEmployeeMobileCredential = async (id: string,
    mobileCredentialIssueInput?: MobileCredentialIssueInput, options?: Parameters<typeof customFetch>[1]): Promise<MobileCredentialIssued> => {

  return customFetch<MobileCredentialIssued>(getIssueEmployeeMobileCredentialUrl(id),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(mobileCredentialIssueInput)
  }
);}





export const getIssueEmployeeMobileCredentialMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof issueEmployeeMobileCredential>>, TError,{id: string;data?: BodyType<MobileCredentialIssueInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof issueEmployeeMobileCredential>>, TError,{id: string;data?: BodyType<MobileCredentialIssueInput>}, TContext> => {

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

          return  issueEmployeeMobileCredential(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type IssueEmployeeMobileCredentialMutationResult = NonNullable<Awaited<ReturnType<typeof issueEmployeeMobileCredential>>>
    export type IssueEmployeeMobileCredentialMutationBody = BodyType<MobileCredentialIssueInput> | undefined
    export type IssueEmployeeMobileCredentialMutationError = ErrorType<void>

    /**
 * @summary Emite o rota una credencial móvil de empleado
 */
export const useIssueEmployeeMobileCredential = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof issueEmployeeMobileCredential>>, TError,{id: string;data?: BodyType<MobileCredentialIssueInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof issueEmployeeMobileCredential>>,
        TError,
        {id: string;data?: BodyType<MobileCredentialIssueInput>},
        TContext
      > => {
      return useMutation(getIssueEmployeeMobileCredentialMutationOptions(options));
    }

export const getRevokeEmployeeMobileCredentialUrl = (id: string,) => {




  return `/api/employees/${id}/mobile-credential`
}

/**
 * @summary Revoca una credencial móvil
 */
export const revokeEmployeeMobileCredential = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getRevokeEmployeeMobileCredentialUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





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

const mutationKey = ['revokeEmployeeMobileCredential'];
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 revokeEmployeeMobileCredential>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  revokeEmployeeMobileCredential(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type RevokeEmployeeMobileCredentialMutationResult = NonNullable<Awaited<ReturnType<typeof revokeEmployeeMobileCredential>>>

    export type RevokeEmployeeMobileCredentialMutationError = ErrorType<void>

    /**
 * @summary Revoca una credencial móvil
 */
export const useRevokeEmployeeMobileCredential = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof revokeEmployeeMobileCredential>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof revokeEmployeeMobileCredential>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getRevokeEmployeeMobileCredentialMutationOptions(options));
    }

export const getGetMyEmployeeProfileUrl = () => {




  return `/api/employees/me`
}

/**
 * @summary Devuelve el perfil propio del empleado móvil
 */
export const getMyEmployeeProfile = async ( options?: Parameters<typeof customFetch>[1]): Promise<Employee> => {

  return customFetch<Employee>(getGetMyEmployeeProfileUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMyEmployeeProfileQueryKey = () => {
    return [
    `/api/employees/me`
    ] as const;
    }


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

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

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



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





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

export type GetMyEmployeeProfileQueryResult = NonNullable<Awaited<ReturnType<typeof getMyEmployeeProfile>>>
export type GetMyEmployeeProfileQueryError = ErrorType<unknown>


/**
 * @summary Devuelve el perfil propio del empleado móvil
 */

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

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

  const queryOptions = getGetMyEmployeeProfileQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListAttendanceUrl = () => {




  return `/api/attendance`
}

/**
 * @summary Libro de asistencia
 */
export const listAttendance = async ( options?: Parameters<typeof customFetch>[1]): Promise<AttendanceRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListAttendanceQueryResult = NonNullable<Awaited<ReturnType<typeof listAttendance>>>
export type ListAttendanceQueryError = ErrorType<unknown>


/**
 * @summary Libro de asistencia
 */

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

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

  const queryOptions = getListAttendanceQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getRecordAttendanceUrl = () => {




  return `/api/attendance`
}

/**
 * @summary Registra una marcación validada
 */
export const recordAttendance = async (attendanceInput: AttendanceInput, options?: Parameters<typeof customFetch>[1]): Promise<AttendanceRecord> => {

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





export const getRecordAttendanceMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof recordAttendance>>, TError,{data: BodyType<AttendanceInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof recordAttendance>>, TError,{data: BodyType<AttendanceInput>}, TContext> => {

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

          return  recordAttendance(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type RecordAttendanceMutationResult = NonNullable<Awaited<ReturnType<typeof recordAttendance>>>
    export type RecordAttendanceMutationBody = BodyType<AttendanceInput>
    export type RecordAttendanceMutationError = ErrorType<unknown>

    /**
 * @summary Registra una marcación validada
 */
export const useRecordAttendance = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof recordAttendance>>, TError,{data: BodyType<AttendanceInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof recordAttendance>>,
        TError,
        {data: BodyType<AttendanceInput>},
        TContext
      > => {
      return useMutation(getRecordAttendanceMutationOptions(options));
    }

export const getListMyAttendanceUrl = () => {




  return `/api/attendance/me`
}

/**
 * @summary Lista la asistencia propia del empleado móvil
 */
export const listMyAttendance = async ( options?: Parameters<typeof customFetch>[1]): Promise<AttendanceRecord[]> => {

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


  }
);}





export const getListMyAttendanceQueryKey = () => {
    return [
    `/api/attendance/me`
    ] as const;
    }


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

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

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



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





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

export type ListMyAttendanceQueryResult = NonNullable<Awaited<ReturnType<typeof listMyAttendance>>>
export type ListMyAttendanceQueryError = ErrorType<unknown>


/**
 * @summary Lista la asistencia propia del empleado móvil
 */

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

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

  const queryOptions = getListMyAttendanceQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getRegisterMobileDeviceUrl = () => {




  return `/api/mobile/devices/register`
}

/**
 * @summary Registra una instalación móvil para aprobación corporativa
 */
export const registerMobileDevice = async (deviceRegistrationInput: DeviceRegistrationInput, options?: Parameters<typeof customFetch>[1]): Promise<DeviceStatus> => {

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





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

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

          return  registerMobileDevice(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type RegisterMobileDeviceMutationResult = NonNullable<Awaited<ReturnType<typeof registerMobileDevice>>>
    export type RegisterMobileDeviceMutationBody = BodyType<DeviceRegistrationInput>
    export type RegisterMobileDeviceMutationError = ErrorType<void>

    /**
 * @summary Registra una instalación móvil para aprobación corporativa
 */
export const useRegisterMobileDevice = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof registerMobileDevice>>, TError,{data: BodyType<DeviceRegistrationInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof registerMobileDevice>>,
        TError,
        {data: BodyType<DeviceRegistrationInput>},
        TContext
      > => {
      return useMutation(getRegisterMobileDeviceMutationOptions(options));
    }

export const getGetMobileDeviceStatusUrl = () => {




  return `/api/mobile/devices/status`
}

/**
 * @summary Consulta el estado del dispositivo móvil enlazado
 */
export const getMobileDeviceStatus = async ( options?: Parameters<typeof customFetch>[1]): Promise<DeviceStatus> => {

  return customFetch<DeviceStatus>(getGetMobileDeviceStatusUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMobileDeviceStatusQueryKey = () => {
    return [
    `/api/mobile/devices/status`
    ] as const;
    }


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

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

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



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





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

export type GetMobileDeviceStatusQueryResult = NonNullable<Awaited<ReturnType<typeof getMobileDeviceStatus>>>
export type GetMobileDeviceStatusQueryError = ErrorType<unknown>


/**
 * @summary Consulta el estado del dispositivo móvil enlazado
 */

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

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

  const queryOptions = getGetMobileDeviceStatusQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getApproveDeviceUrl = (id: string,) => {




  return `/api/devices/${id}/approve`
}

/**
 * @summary Aprueba un dispositivo móvil
 */
export const approveDevice = async (id: string,
    deviceDecisionInput?: DeviceDecisionInput, options?: Parameters<typeof customFetch>[1]): Promise<DeviceStatus> => {

  return customFetch<DeviceStatus>(getApproveDeviceUrl(id),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(deviceDecisionInput)
  }
);}





export const getApproveDeviceMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof approveDevice>>, TError,{id: string;data?: BodyType<DeviceDecisionInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof approveDevice>>, TError,{id: string;data?: BodyType<DeviceDecisionInput>}, TContext> => {

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

          return  approveDevice(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type ApproveDeviceMutationResult = NonNullable<Awaited<ReturnType<typeof approveDevice>>>
    export type ApproveDeviceMutationBody = BodyType<DeviceDecisionInput> | undefined
    export type ApproveDeviceMutationError = ErrorType<void>

    /**
 * @summary Aprueba un dispositivo móvil
 */
export const useApproveDevice = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof approveDevice>>, TError,{id: string;data?: BodyType<DeviceDecisionInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof approveDevice>>,
        TError,
        {id: string;data?: BodyType<DeviceDecisionInput>},
        TContext
      > => {
      return useMutation(getApproveDeviceMutationOptions(options));
    }

export const getRevokeDeviceUrl = (id: string,) => {




  return `/api/devices/${id}/revoke`
}

/**
 * @summary Revoca o reemplaza un dispositivo móvil
 */
export const revokeDevice = async (id: string,
    deviceDecisionInput?: DeviceDecisionInput, options?: Parameters<typeof customFetch>[1]): Promise<DeviceStatus> => {

  return customFetch<DeviceStatus>(getRevokeDeviceUrl(id),
  {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(deviceDecisionInput)
  }
);}





export const getRevokeDeviceMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof revokeDevice>>, TError,{id: string;data?: BodyType<DeviceDecisionInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof revokeDevice>>, TError,{id: string;data?: BodyType<DeviceDecisionInput>}, TContext> => {

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

          return  revokeDevice(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type RevokeDeviceMutationResult = NonNullable<Awaited<ReturnType<typeof revokeDevice>>>
    export type RevokeDeviceMutationBody = BodyType<DeviceDecisionInput> | undefined
    export type RevokeDeviceMutationError = ErrorType<void>

    /**
 * @summary Revoca o reemplaza un dispositivo móvil
 */
export const useRevokeDevice = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof revokeDevice>>, TError,{id: string;data?: BodyType<DeviceDecisionInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof revokeDevice>>,
        TError,
        {id: string;data?: BodyType<DeviceDecisionInput>},
        TContext
      > => {
      return useMutation(getRevokeDeviceMutationOptions(options));
    }

export const getGetProjectMainQrForPrintUrl = (id: string,) => {




  return `/api/projects/${id}/qr/main`
}

/**
 * @summary Obtiene el QR principal para impresión corporativa
 */
export const getProjectMainQrForPrint = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<ProjectQrResource> => {

  return customFetch<ProjectQrResource>(getGetProjectMainQrForPrintUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetProjectMainQrForPrintQueryKey = (id: string,) => {
    return [
    `/api/projects/${id}/qr/main`
    ] as const;
    }


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

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

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



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





   return  { queryKey, queryFn, enabled: id !== null && id !== undefined, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof getProjectMainQrForPrint>>, TError, TData> & { queryKey: QueryKey }
}

export type GetProjectMainQrForPrintQueryResult = NonNullable<Awaited<ReturnType<typeof getProjectMainQrForPrint>>>
export type GetProjectMainQrForPrintQueryError = ErrorType<void>


/**
 * @summary Obtiene el QR principal para impresión corporativa
 */

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

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

  const queryOptions = getGetProjectMainQrForPrintQueryOptions(id,options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateProjectMainQrUrl = (id: string,) => {




  return `/api/projects/${id}/qr/main`
}

/**
 * Solo personal corporativo autorizado puede crear, imprimir o descargar este recurso estático.
 * @summary Crea o rota el QR principal corporativo de un proyecto
 */
export const createProjectMainQr = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<ProjectQrResource> => {

  return customFetch<ProjectQrResource>(getCreateProjectMainQrUrl(id),
  {
    ...options,
    method: 'POST'


  }
);}





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

const mutationKey = ['createProjectMainQr'];
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 createProjectMainQr>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  createProjectMainQr(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateProjectMainQrMutationResult = NonNullable<Awaited<ReturnType<typeof createProjectMainQr>>>

    export type CreateProjectMainQrMutationError = ErrorType<void>

    /**
 * @summary Crea o rota el QR principal corporativo de un proyecto
 */
export const useCreateProjectMainQr = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createProjectMainQr>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createProjectMainQr>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getCreateProjectMainQrMutationOptions(options));
    }

export const getCreateQrDisplayChallengeUrl = (id: string,) => {




  return `/api/worksites/${id}/qr/display-challenge`
}

/**
 * El desafío firmado expira en 30–60 segundos, es de un solo uso y solo puede mostrarlo un supervisor explícitamente autorizado o personal corporativo.
 * @summary Emite un desafío QR rotativo de corta duración
 */
export const createQrDisplayChallenge = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<QrDisplayChallenge> => {

  return customFetch<QrDisplayChallenge>(getCreateQrDisplayChallengeUrl(id),
  {
    ...options,
    method: 'POST'


  }
);}





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

const mutationKey = ['createQrDisplayChallenge'];
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 createQrDisplayChallenge>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  createQrDisplayChallenge(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateQrDisplayChallengeMutationResult = NonNullable<Awaited<ReturnType<typeof createQrDisplayChallenge>>>

    export type CreateQrDisplayChallengeMutationError = ErrorType<void>

    /**
 * @summary Emite un desafío QR rotativo de corta duración
 */
export const useCreateQrDisplayChallenge = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createQrDisplayChallenge>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createQrDisplayChallenge>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getCreateQrDisplayChallengeMutationOptions(options));
    }

export const getScanAttendanceQrUrl = () => {




  return `/api/attendance/scan`
}

/**
 * @summary Valida un escaneo QR de asistencia
 */
export const scanAttendanceQr = async (attendanceScanInput: AttendanceScanInput, options?: Parameters<typeof customFetch>[1]): Promise<AttendanceScanResult> => {

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





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

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

          return  scanAttendanceQr(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type ScanAttendanceQrMutationResult = NonNullable<Awaited<ReturnType<typeof scanAttendanceQr>>>
    export type ScanAttendanceQrMutationBody = BodyType<AttendanceScanInput>
    export type ScanAttendanceQrMutationError = ErrorType<void>

    /**
 * @summary Valida un escaneo QR de asistencia
 */
export const useScanAttendanceQr = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof scanAttendanceQr>>, TError,{data: BodyType<AttendanceScanInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof scanAttendanceQr>>,
        TError,
        {data: BodyType<AttendanceScanInput>},
        TContext
      > => {
      return useMutation(getScanAttendanceQrMutationOptions(options));
    }

export const getListSecurityAttemptsUrl = () => {




  return `/api/security/attempts`
}

/**
 * @summary Lista intentos de asistencia aceptados y rechazados
 */
export const listSecurityAttempts = async ( options?: Parameters<typeof customFetch>[1]): Promise<SecurityAttempt[]> => {

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


  }
);}





export const getListSecurityAttemptsQueryKey = () => {
    return [
    `/api/security/attempts`
    ] as const;
    }


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

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

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



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





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

export type ListSecurityAttemptsQueryResult = NonNullable<Awaited<ReturnType<typeof listSecurityAttempts>>>
export type ListSecurityAttemptsQueryError = ErrorType<unknown>


/**
 * @summary Lista intentos de asistencia aceptados y rechazados
 */

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

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

  const queryOptions = getListSecurityAttemptsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getUpdateWorksiteSecurityConfigUrl = (id: string,) => {




  return `/api/worksites/${id}/security-config`
}

/**
 * @summary Configura geofence y horario de un worksite
 */
export const updateWorksiteSecurityConfig = async (id: string,
    worksiteSecurityConfig: WorksiteSecurityConfig, options?: Parameters<typeof customFetch>[1]): Promise<WorksiteSecurityConfig> => {

  return customFetch<WorksiteSecurityConfig>(getUpdateWorksiteSecurityConfigUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(worksiteSecurityConfig)
  }
);}





export const getUpdateWorksiteSecurityConfigMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateWorksiteSecurityConfig>>, TError,{id: string;data: BodyType<WorksiteSecurityConfig>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateWorksiteSecurityConfig>>, TError,{id: string;data: BodyType<WorksiteSecurityConfig>}, TContext> => {

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

          return  updateWorksiteSecurityConfig(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateWorksiteSecurityConfigMutationResult = NonNullable<Awaited<ReturnType<typeof updateWorksiteSecurityConfig>>>
    export type UpdateWorksiteSecurityConfigMutationBody = BodyType<WorksiteSecurityConfig>
    export type UpdateWorksiteSecurityConfigMutationError = ErrorType<void>

    /**
 * @summary Configura geofence y horario de un worksite
 */
export const useUpdateWorksiteSecurityConfig = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateWorksiteSecurityConfig>>, TError,{id: string;data: BodyType<WorksiteSecurityConfig>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateWorksiteSecurityConfig>>,
        TError,
        {id: string;data: BodyType<WorksiteSecurityConfig>},
        TContext
      > => {
      return useMutation(getUpdateWorksiteSecurityConfigMutationOptions(options));
    }

export const getListSecurityEventsUrl = () => {




  return `/api/security/events`
}

/**
 * @summary Lista eventos de seguridad
 */
export const listSecurityEvents = async ( options?: Parameters<typeof customFetch>[1]): Promise<SecurityEvent[]> => {

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


  }
);}





export const getListSecurityEventsQueryKey = () => {
    return [
    `/api/security/events`
    ] as const;
    }


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

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

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



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





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

export type ListSecurityEventsQueryResult = NonNullable<Awaited<ReturnType<typeof listSecurityEvents>>>
export type ListSecurityEventsQueryError = ErrorType<unknown>


/**
 * @summary Lista eventos de seguridad
 */

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

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

  const queryOptions = getListSecurityEventsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListPoliciesUrl = () => {




  return `/api/policies`
}

/**
 * @summary Lista políticas vigentes
 */
export const listPolicies = async ( options?: Parameters<typeof customFetch>[1]): Promise<Policy[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListPoliciesQueryResult = NonNullable<Awaited<ReturnType<typeof listPolicies>>>
export type ListPoliciesQueryError = ErrorType<unknown>


/**
 * @summary Lista políticas vigentes
 */

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

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

  const queryOptions = getListPoliciesQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreatePolicyUrl = () => {




  return `/api/policies`
}

/**
 * @summary Crea una política
 */
export const createPolicy = async (policyInput: PolicyInput, options?: Parameters<typeof customFetch>[1]): Promise<Policy> => {

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





export const getCreatePolicyMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createPolicy>>, TError,{data: BodyType<PolicyInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createPolicy>>, TError,{data: BodyType<PolicyInput>}, TContext> => {

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

          return  createPolicy(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreatePolicyMutationResult = NonNullable<Awaited<ReturnType<typeof createPolicy>>>
    export type CreatePolicyMutationBody = BodyType<PolicyInput>
    export type CreatePolicyMutationError = ErrorType<unknown>

    /**
 * @summary Crea una política
 */
export const useCreatePolicy = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createPolicy>>, TError,{data: BodyType<PolicyInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createPolicy>>,
        TError,
        {data: BodyType<PolicyInput>},
        TContext
      > => {
      return useMutation(getCreatePolicyMutationOptions(options));
    }

export const getUpdatePolicyUrl = (id: string,) => {




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

/**
 * @summary Actualiza una política
 */
export const updatePolicy = async (id: string,
    policyUpdate: PolicyUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Policy> => {

  return customFetch<Policy>(getUpdatePolicyUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(policyUpdate)
  }
);}





export const getUpdatePolicyMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updatePolicy>>, TError,{id: string;data: BodyType<PolicyUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updatePolicy>>, TError,{id: string;data: BodyType<PolicyUpdate>}, TContext> => {

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

          return  updatePolicy(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdatePolicyMutationResult = NonNullable<Awaited<ReturnType<typeof updatePolicy>>>
    export type UpdatePolicyMutationBody = BodyType<PolicyUpdate>
    export type UpdatePolicyMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza una política
 */
export const useUpdatePolicy = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updatePolicy>>, TError,{id: string;data: BodyType<PolicyUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updatePolicy>>,
        TError,
        {id: string;data: BodyType<PolicyUpdate>},
        TContext
      > => {
      return useMutation(getUpdatePolicyMutationOptions(options));
    }

export const getDeletePolicyUrl = (id: string,) => {




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

/**
 * @summary Archiva una política
 */
export const deletePolicy = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeletePolicyUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeletePolicyMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deletePolicy>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deletePolicy>>, TError,{id: string}, TContext> => {

const mutationKey = ['deletePolicy'];
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 deletePolicy>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deletePolicy(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeletePolicyMutationResult = NonNullable<Awaited<ReturnType<typeof deletePolicy>>>

    export type DeletePolicyMutationError = ErrorType<unknown>

    /**
 * @summary Archiva una política
 */
export const useDeletePolicy = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deletePolicy>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deletePolicy>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeletePolicyMutationOptions(options));
    }

export const getListDocumentsUrl = () => {




  return `/api/documents`
}

/**
 * @summary Lista documentos de operación
 */
export const listDocuments = async ( options?: Parameters<typeof customFetch>[1]): Promise<Document[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListDocumentsQueryResult = NonNullable<Awaited<ReturnType<typeof listDocuments>>>
export type ListDocumentsQueryError = ErrorType<unknown>


/**
 * @summary Lista documentos de operación
 */

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

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

  const queryOptions = getListDocumentsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateDocumentUrl = () => {




  return `/api/documents`
}

/**
 * @summary Registra un documento
 */
export const createDocument = async (documentInput: DocumentInput, options?: Parameters<typeof customFetch>[1]): Promise<Document> => {

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





export const getCreateDocumentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createDocument>>, TError,{data: BodyType<DocumentInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createDocument>>, TError,{data: BodyType<DocumentInput>}, TContext> => {

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

          return  createDocument(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof createDocument>>>
    export type CreateDocumentMutationBody = BodyType<DocumentInput>
    export type CreateDocumentMutationError = ErrorType<unknown>

    /**
 * @summary Registra un documento
 */
export const useCreateDocument = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createDocument>>, TError,{data: BodyType<DocumentInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createDocument>>,
        TError,
        {data: BodyType<DocumentInput>},
        TContext
      > => {
      return useMutation(getCreateDocumentMutationOptions(options));
    }

export const getUpdateDocumentUrl = (id: string,) => {




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

/**
 * @summary Actualiza un documento
 */
export const updateDocument = async (id: string,
    documentUpdate: DocumentUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Document> => {

  return customFetch<Document>(getUpdateDocumentUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(documentUpdate)
  }
);}





export const getUpdateDocumentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateDocument>>, TError,{id: string;data: BodyType<DocumentUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateDocument>>, TError,{id: string;data: BodyType<DocumentUpdate>}, TContext> => {

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

          return  updateDocument(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof updateDocument>>>
    export type UpdateDocumentMutationBody = BodyType<DocumentUpdate>
    export type UpdateDocumentMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza un documento
 */
export const useUpdateDocument = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateDocument>>, TError,{id: string;data: BodyType<DocumentUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateDocument>>,
        TError,
        {id: string;data: BodyType<DocumentUpdate>},
        TContext
      > => {
      return useMutation(getUpdateDocumentMutationOptions(options));
    }

export const getDeleteDocumentUrl = (id: string,) => {




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

/**
 * @summary Archiva un documento
 */
export const deleteDocument = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteDocumentUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteDocumentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteDocument>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteDocument>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteDocument'];
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 deleteDocument>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteDocument(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof deleteDocument>>>

    export type DeleteDocumentMutationError = ErrorType<unknown>

    /**
 * @summary Archiva un documento
 */
export const useDeleteDocument = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteDocument>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteDocument>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteDocumentMutationOptions(options));
    }

export const getListAppointmentsUrl = () => {




  return `/api/appointments`
}

/**
 * @summary Lista citas y visitas
 */
export const listAppointments = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListAppointmentsQueryResult = NonNullable<Awaited<ReturnType<typeof listAppointments>>>
export type ListAppointmentsQueryError = ErrorType<unknown>


/**
 * @summary Lista citas y visitas
 */

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

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

  const queryOptions = getListAppointmentsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateAppointmentUrl = () => {




  return `/api/appointments`
}

/**
 * @summary Crea una cita
 */
export const createAppointment = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateAppointmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAppointment>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createAppointment>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createAppointment(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateAppointmentMutationResult = NonNullable<Awaited<ReturnType<typeof createAppointment>>>
    export type CreateAppointmentMutationBody = BodyType<PlatformRecordInput>
    export type CreateAppointmentMutationError = ErrorType<unknown>

    /**
 * @summary Crea una cita
 */
export const useCreateAppointment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAppointment>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createAppointment>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateAppointmentMutationOptions(options));
    }

export const getUpdateAppointmentUrl = (id: string,) => {




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

export const updateAppointment = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateAppointmentUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateAppointmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateAppointment>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateAppointment>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateAppointment(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateAppointmentMutationResult = NonNullable<Awaited<ReturnType<typeof updateAppointment>>>
    export type UpdateAppointmentMutationBody = BodyType<PlatformRecordInput>
    export type UpdateAppointmentMutationError = ErrorType<unknown>

    export const useUpdateAppointment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateAppointment>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateAppointment>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateAppointmentMutationOptions(options));
    }

export const getDeleteAppointmentUrl = (id: string,) => {




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

export const deleteAppointment = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeleteAppointmentUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeleteAppointmentMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteAppointment>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deleteAppointment>>, TError,{id: string}, TContext> => {

const mutationKey = ['deleteAppointment'];
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 deleteAppointment>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deleteAppointment(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteAppointmentMutationResult = NonNullable<Awaited<ReturnType<typeof deleteAppointment>>>

    export type DeleteAppointmentMutationError = ErrorType<unknown>

    export const useDeleteAppointment = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteAppointment>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteAppointment>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeleteAppointmentMutationOptions(options));
    }

export const getListAlertsUrl = () => {




  return `/api/alerts`
}

/**
 * @summary Lista alertas operativas
 */
export const listAlerts = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListAlertsQueryResult = NonNullable<Awaited<ReturnType<typeof listAlerts>>>
export type ListAlertsQueryError = ErrorType<unknown>


/**
 * @summary Lista alertas operativas
 */

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

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

  const queryOptions = getListAlertsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateAlertUrl = () => {




  return `/api/alerts`
}

/**
 * @summary Crea una alerta operativa
 */
export const createAlert = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateAlertMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAlert>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createAlert>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createAlert(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateAlertMutationResult = NonNullable<Awaited<ReturnType<typeof createAlert>>>
    export type CreateAlertMutationBody = BodyType<PlatformRecordInput>
    export type CreateAlertMutationError = ErrorType<unknown>

    /**
 * @summary Crea una alerta operativa
 */
export const useCreateAlert = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createAlert>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createAlert>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateAlertMutationOptions(options));
    }

export const getUpdateAlertUrl = (id: string,) => {




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

export const updateAlert = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateAlertUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateAlertMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateAlert>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateAlert>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateAlert(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateAlertMutationResult = NonNullable<Awaited<ReturnType<typeof updateAlert>>>
    export type UpdateAlertMutationBody = BodyType<PlatformRecordInput>
    export type UpdateAlertMutationError = ErrorType<unknown>

    export const useUpdateAlert = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateAlert>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateAlert>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateAlertMutationOptions(options));
    }

export const getListAuditLogsUrl = () => {




  return `/api/audit`
}

/**
 * @summary Lista auditoría inmutable
 */
export const listAuditLogs = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListAuditLogsQueryResult = NonNullable<Awaited<ReturnType<typeof listAuditLogs>>>
export type ListAuditLogsQueryError = ErrorType<unknown>


/**
 * @summary Lista auditoría inmutable
 */

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

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

  const queryOptions = getListAuditLogsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListRolesUrl = () => {




  return `/api/roles`
}

/**
 * @summary Lista roles y permisos
 */
export const listRoles = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListRolesQueryResult = NonNullable<Awaited<ReturnType<typeof listRoles>>>
export type ListRolesQueryError = ErrorType<unknown>


/**
 * @summary Lista roles y permisos
 */

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

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

  const queryOptions = getListRolesQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateRoleUrl = () => {




  return `/api/roles`
}

/**
 * @summary Crea un rol
 */
export const createRole = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateRoleMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createRole>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createRole>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createRole(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateRoleMutationResult = NonNullable<Awaited<ReturnType<typeof createRole>>>
    export type CreateRoleMutationBody = BodyType<PlatformRecordInput>
    export type CreateRoleMutationError = ErrorType<unknown>

    /**
 * @summary Crea un rol
 */
export const useCreateRole = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createRole>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createRole>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateRoleMutationOptions(options));
    }

export const getUpdateRoleUrl = (id: string,) => {




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

export const updateRole = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateRoleUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateRoleMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateRole>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateRole>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateRole(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateRoleMutationResult = NonNullable<Awaited<ReturnType<typeof updateRole>>>
    export type UpdateRoleMutationBody = BodyType<PlatformRecordInput>
    export type UpdateRoleMutationError = ErrorType<unknown>

    export const useUpdateRole = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateRole>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateRole>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateRoleMutationOptions(options));
    }

export const getListDevicesUrl = () => {




  return `/api/devices`
}

/**
 * @summary Lista dispositivos autorizados
 */
export const listDevices = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListDevicesQueryResult = NonNullable<Awaited<ReturnType<typeof listDevices>>>
export type ListDevicesQueryError = ErrorType<unknown>


/**
 * @summary Lista dispositivos autorizados
 */

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

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

  const queryOptions = getListDevicesQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getUpdateDeviceUrl = (id: string,) => {




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

export const updateDevice = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateDeviceUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateDeviceMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateDevice>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateDevice>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateDevice(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateDeviceMutationResult = NonNullable<Awaited<ReturnType<typeof updateDevice>>>
    export type UpdateDeviceMutationBody = BodyType<PlatformRecordInput>
    export type UpdateDeviceMutationError = ErrorType<unknown>

    export const useUpdateDevice = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateDevice>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateDevice>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateDeviceMutationOptions(options));
    }

export const getListJobPostingsUrl = () => {




  return `/api/jobs`
}

/**
 * @summary Lista empleos
 */
export const listJobPostings = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListJobPostingsQueryResult = NonNullable<Awaited<ReturnType<typeof listJobPostings>>>
export type ListJobPostingsQueryError = ErrorType<unknown>


/**
 * @summary Lista empleos
 */

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

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

  const queryOptions = getListJobPostingsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateJobPostingUrl = () => {




  return `/api/jobs`
}

/**
 * @summary Publica un empleo
 */
export const createJobPosting = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateJobPostingMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createJobPosting>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createJobPosting>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createJobPosting(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateJobPostingMutationResult = NonNullable<Awaited<ReturnType<typeof createJobPosting>>>
    export type CreateJobPostingMutationBody = BodyType<PlatformRecordInput>
    export type CreateJobPostingMutationError = ErrorType<unknown>

    /**
 * @summary Publica un empleo
 */
export const useCreateJobPosting = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createJobPosting>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createJobPosting>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateJobPostingMutationOptions(options));
    }

export const getUpdateJobPostingUrl = (id: string,) => {




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

export const updateJobPosting = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateJobPostingUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateJobPostingMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateJobPosting>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateJobPosting>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateJobPosting(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateJobPostingMutationResult = NonNullable<Awaited<ReturnType<typeof updateJobPosting>>>
    export type UpdateJobPostingMutationBody = BodyType<PlatformRecordInput>
    export type UpdateJobPostingMutationError = ErrorType<unknown>

    export const useUpdateJobPosting = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateJobPosting>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateJobPosting>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateJobPostingMutationOptions(options));
    }

export const getListJobApplicationsUrl = () => {




  return `/api/applications`
}

/**
 * @summary Lista solicitudes de empleo
 */
export const listJobApplications = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListJobApplicationsQueryResult = NonNullable<Awaited<ReturnType<typeof listJobApplications>>>
export type ListJobApplicationsQueryError = ErrorType<unknown>


/**
 * @summary Lista solicitudes de empleo
 */

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

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

  const queryOptions = getListJobApplicationsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateJobApplicationUrl = () => {




  return `/api/applications`
}

/**
 * @summary Recibe una solicitud de empleo
 */
export const createJobApplication = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateJobApplicationMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createJobApplication>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createJobApplication>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createJobApplication(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateJobApplicationMutationResult = NonNullable<Awaited<ReturnType<typeof createJobApplication>>>
    export type CreateJobApplicationMutationBody = BodyType<PlatformRecordInput>
    export type CreateJobApplicationMutationError = ErrorType<unknown>

    /**
 * @summary Recibe una solicitud de empleo
 */
export const useCreateJobApplication = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createJobApplication>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createJobApplication>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateJobApplicationMutationOptions(options));
    }

export const getUpdateJobApplicationUrl = (id: string,) => {




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

export const updateJobApplication = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateJobApplicationUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateJobApplicationMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateJobApplication>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateJobApplication>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateJobApplication(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateJobApplicationMutationResult = NonNullable<Awaited<ReturnType<typeof updateJobApplication>>>
    export type UpdateJobApplicationMutationBody = BodyType<PlatformRecordInput>
    export type UpdateJobApplicationMutationError = ErrorType<unknown>

    export const useUpdateJobApplication = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateJobApplication>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateJobApplication>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateJobApplicationMutationOptions(options));
    }

export const getListResourcesUrl = () => {




  return `/api/resources`
}

/**
 * @summary Lista recursos y artículos
 */
export const listResources = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListResourcesQueryResult = NonNullable<Awaited<ReturnType<typeof listResources>>>
export type ListResourcesQueryError = ErrorType<unknown>


/**
 * @summary Lista recursos y artículos
 */

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

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

  const queryOptions = getListResourcesQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateResourceUrl = () => {




  return `/api/resources`
}

/**
 * @summary Crea un recurso
 */
export const createResource = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateResourceMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createResource>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createResource>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createResource(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateResourceMutationResult = NonNullable<Awaited<ReturnType<typeof createResource>>>
    export type CreateResourceMutationBody = BodyType<PlatformRecordInput>
    export type CreateResourceMutationError = ErrorType<unknown>

    /**
 * @summary Crea un recurso
 */
export const useCreateResource = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createResource>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createResource>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateResourceMutationOptions(options));
    }

export const getUpdateResourceUrl = (id: string,) => {




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

export const updateResource = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateResourceUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateResourceMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateResource>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateResource>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateResource(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateResourceMutationResult = NonNullable<Awaited<ReturnType<typeof updateResource>>>
    export type UpdateResourceMutationBody = BodyType<PlatformRecordInput>
    export type UpdateResourceMutationError = ErrorType<unknown>

    export const useUpdateResource = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateResource>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateResource>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateResourceMutationOptions(options));
    }

export const getListMediaUrl = () => {




  return `/api/media`
}

/**
 * @summary Lista medios de proyectos
 */
export const listMedia = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListMediaQueryResult = NonNullable<Awaited<ReturnType<typeof listMedia>>>
export type ListMediaQueryError = ErrorType<unknown>


/**
 * @summary Lista medios de proyectos
 */

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

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

  const queryOptions = getListMediaQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateMediaUrl = () => {




  return `/api/media`
}

/**
 * @summary Registra una imagen o video
 */
export const createMedia = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateMediaMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createMedia>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createMedia>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createMedia(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateMediaMutationResult = NonNullable<Awaited<ReturnType<typeof createMedia>>>
    export type CreateMediaMutationBody = BodyType<PlatformRecordInput>
    export type CreateMediaMutationError = ErrorType<unknown>

    /**
 * @summary Registra una imagen o video
 */
export const useCreateMedia = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createMedia>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createMedia>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateMediaMutationOptions(options));
    }

export const getListPublicEntriesUrl = () => {




  return `/api/public-entries`
}

/**
 * @summary Lista el contenido público editable desde el cPanel
 */
export const listPublicEntries = async ( options?: Parameters<typeof customFetch>[1]): Promise<PublicEntry[]> => {

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


  }
);}





export const getListPublicEntriesQueryKey = () => {
    return [
    `/api/public-entries`
    ] as const;
    }


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

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

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



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





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

export type ListPublicEntriesQueryResult = NonNullable<Awaited<ReturnType<typeof listPublicEntries>>>
export type ListPublicEntriesQueryError = ErrorType<unknown>


/**
 * @summary Lista el contenido público editable desde el cPanel
 */

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

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

  const queryOptions = getListPublicEntriesQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreatePublicEntryUrl = () => {




  return `/api/public-entries`
}

/**
 * @summary Crea una publicación, proyecto, servicio o página legal
 */
export const createPublicEntry = async (publicEntryInput: PublicEntryInput, options?: Parameters<typeof customFetch>[1]): Promise<PublicEntry> => {

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





export const getCreatePublicEntryMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createPublicEntry>>, TError,{data: BodyType<PublicEntryInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createPublicEntry>>, TError,{data: BodyType<PublicEntryInput>}, TContext> => {

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

          return  createPublicEntry(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreatePublicEntryMutationResult = NonNullable<Awaited<ReturnType<typeof createPublicEntry>>>
    export type CreatePublicEntryMutationBody = BodyType<PublicEntryInput>
    export type CreatePublicEntryMutationError = ErrorType<unknown>

    /**
 * @summary Crea una publicación, proyecto, servicio o página legal
 */
export const useCreatePublicEntry = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createPublicEntry>>, TError,{data: BodyType<PublicEntryInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createPublicEntry>>,
        TError,
        {data: BodyType<PublicEntryInput>},
        TContext
      > => {
      return useMutation(getCreatePublicEntryMutationOptions(options));
    }

export const getUpdatePublicEntryUrl = (id: string,) => {




  return `/api/public-entries/${id}`
}

/**
 * @summary Actualiza contenido público
 */
export const updatePublicEntry = async (id: string,
    publicEntryUpdate: PublicEntryUpdate, options?: Parameters<typeof customFetch>[1]): Promise<PublicEntry> => {

  return customFetch<PublicEntry>(getUpdatePublicEntryUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(publicEntryUpdate)
  }
);}





export const getUpdatePublicEntryMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updatePublicEntry>>, TError,{id: string;data: BodyType<PublicEntryUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updatePublicEntry>>, TError,{id: string;data: BodyType<PublicEntryUpdate>}, TContext> => {

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

          return  updatePublicEntry(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdatePublicEntryMutationResult = NonNullable<Awaited<ReturnType<typeof updatePublicEntry>>>
    export type UpdatePublicEntryMutationBody = BodyType<PublicEntryUpdate>
    export type UpdatePublicEntryMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza contenido público
 */
export const useUpdatePublicEntry = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updatePublicEntry>>, TError,{id: string;data: BodyType<PublicEntryUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updatePublicEntry>>,
        TError,
        {id: string;data: BodyType<PublicEntryUpdate>},
        TContext
      > => {
      return useMutation(getUpdatePublicEntryMutationOptions(options));
    }

export const getDeletePublicEntryUrl = (id: string,) => {




  return `/api/public-entries/${id}`
}

/**
 * @summary Elimina contenido público
 */
export const deletePublicEntry = async (id: string, options?: Parameters<typeof customFetch>[1]): Promise<void> => {

  return customFetch<void>(getDeletePublicEntryUrl(id),
  {
    ...options,
    method: 'DELETE'


  }
);}





export const getDeletePublicEntryMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deletePublicEntry>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof deletePublicEntry>>, TError,{id: string}, TContext> => {

const mutationKey = ['deletePublicEntry'];
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 deletePublicEntry>>, {id: string}> = (props) => {
          const {id} = props ?? {};

          return  deletePublicEntry(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeletePublicEntryMutationResult = NonNullable<Awaited<ReturnType<typeof deletePublicEntry>>>

    export type DeletePublicEntryMutationError = ErrorType<unknown>

    /**
 * @summary Elimina contenido público
 */
export const useDeletePublicEntry = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deletePublicEntry>>, TError,{id: string}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deletePublicEntry>>,
        TError,
        {id: string},
        TContext
      > => {
      return useMutation(getDeletePublicEntryMutationOptions(options));
    }

export const getListPayrollExportsUrl = () => {




  return `/api/payroll/exports`
}

/**
 * @summary Lista exportaciones de nómina
 */
export const listPayrollExports = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





export const getListPayrollExportsQueryKey = () => {
    return [
    `/api/payroll/exports`
    ] as const;
    }


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

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

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



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





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

export type ListPayrollExportsQueryResult = NonNullable<Awaited<ReturnType<typeof listPayrollExports>>>
export type ListPayrollExportsQueryError = ErrorType<unknown>


/**
 * @summary Lista exportaciones de nómina
 */

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

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

  const queryOptions = getListPayrollExportsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreatePayrollExportUrl = () => {




  return `/api/payroll/exports`
}

/**
 * @summary Genera una exportación de nómina
 */
export const createPayrollExport = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreatePayrollExportMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createPayrollExport>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createPayrollExport>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createPayrollExport(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreatePayrollExportMutationResult = NonNullable<Awaited<ReturnType<typeof createPayrollExport>>>
    export type CreatePayrollExportMutationBody = BodyType<PlatformRecordInput>
    export type CreatePayrollExportMutationError = ErrorType<unknown>

    /**
 * @summary Genera una exportación de nómina
 */
export const useCreatePayrollExport = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createPayrollExport>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createPayrollExport>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreatePayrollExportMutationOptions(options));
    }

export const getListLeaveRequestsUrl = () => {




  return `/api/leave-requests`
}

/**
 * @summary Lista licencias y ausencias
 */
export const listLeaveRequests = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





export const getListLeaveRequestsQueryKey = () => {
    return [
    `/api/leave-requests`
    ] as const;
    }


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

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

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



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





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

export type ListLeaveRequestsQueryResult = NonNullable<Awaited<ReturnType<typeof listLeaveRequests>>>
export type ListLeaveRequestsQueryError = ErrorType<unknown>


/**
 * @summary Lista licencias y ausencias
 */

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

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

  const queryOptions = getListLeaveRequestsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateLeaveRequestUrl = () => {




  return `/api/leave-requests`
}

/**
 * @summary Solicita una licencia
 */
export const createLeaveRequest = async (platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

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





export const getCreateLeaveRequestMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createLeaveRequest>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof createLeaveRequest>>, TError,{data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  createLeaveRequest(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateLeaveRequestMutationResult = NonNullable<Awaited<ReturnType<typeof createLeaveRequest>>>
    export type CreateLeaveRequestMutationBody = BodyType<PlatformRecordInput>
    export type CreateLeaveRequestMutationError = ErrorType<unknown>

    /**
 * @summary Solicita una licencia
 */
export const useCreateLeaveRequest = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createLeaveRequest>>, TError,{data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createLeaveRequest>>,
        TError,
        {data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getCreateLeaveRequestMutationOptions(options));
    }

export const getUpdateLeaveRequestUrl = (id: string,) => {




  return `/api/leave-requests/${id}`
}

export const updateLeaveRequest = async (id: string,
    platformRecordInput: PlatformRecordInput, options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord> => {

  return customFetch<PlatformRecord>(getUpdateLeaveRequestUrl(id),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(platformRecordInput)
  }
);}





export const getUpdateLeaveRequestMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateLeaveRequest>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateLeaveRequest>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext> => {

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

          return  updateLeaveRequest(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateLeaveRequestMutationResult = NonNullable<Awaited<ReturnType<typeof updateLeaveRequest>>>
    export type UpdateLeaveRequestMutationBody = BodyType<PlatformRecordInput>
    export type UpdateLeaveRequestMutationError = ErrorType<unknown>

    export const useUpdateLeaveRequest = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateLeaveRequest>>, TError,{id: string;data: BodyType<PlatformRecordInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateLeaveRequest>>,
        TError,
        {id: string;data: BodyType<PlatformRecordInput>},
        TContext
      > => {
      return useMutation(getUpdateLeaveRequestMutationOptions(options));
    }

export const getListMyLeaveRequestsUrl = () => {




  return `/api/leave-requests/me`
}

/**
 * @summary Lista las licencias propias del empleado móvil
 */
export const listMyLeaveRequests = async ( options?: Parameters<typeof customFetch>[1]): Promise<PlatformRecord[]> => {

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


  }
);}





export const getListMyLeaveRequestsQueryKey = () => {
    return [
    `/api/leave-requests/me`
    ] as const;
    }


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

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

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



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





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

export type ListMyLeaveRequestsQueryResult = NonNullable<Awaited<ReturnType<typeof listMyLeaveRequests>>>
export type ListMyLeaveRequestsQueryError = ErrorType<unknown>


/**
 * @summary Lista las licencias propias del empleado móvil
 */

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

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

  const queryOptions = getListMyLeaveRequestsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getGetSettingsUrl = () => {




  return `/api/settings`
}

/**
 * @summary Obtiene configuración de la compañía
 */
export const getSettings = async ( options?: Parameters<typeof customFetch>[1]): Promise<Settings> => {

  return customFetch<Settings>(getGetSettingsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type GetSettingsQueryResult = NonNullable<Awaited<ReturnType<typeof getSettings>>>
export type GetSettingsQueryError = ErrorType<unknown>


/**
 * @summary Obtiene configuración de la compañía
 */

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

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

  const queryOptions = getGetSettingsQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getUpdateSettingsUrl = () => {




  return `/api/settings`
}

/**
 * @summary Actualiza configuración
 */
export const updateSettings = async (settingsUpdate: SettingsUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Settings> => {

  return customFetch<Settings>(getUpdateSettingsUrl(),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(settingsUpdate)
  }
);}





export const getUpdateSettingsMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateSettings>>, TError,{data: BodyType<SettingsUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateSettings>>, TError,{data: BodyType<SettingsUpdate>}, TContext> => {

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

          return  updateSettings(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateSettingsMutationResult = NonNullable<Awaited<ReturnType<typeof updateSettings>>>
    export type UpdateSettingsMutationBody = BodyType<SettingsUpdate>
    export type UpdateSettingsMutationError = ErrorType<unknown>

    /**
 * @summary Actualiza configuración
 */
export const useUpdateSettings = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateSettings>>, TError,{data: BodyType<SettingsUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateSettings>>,
        TError,
        {data: BodyType<SettingsUpdate>},
        TContext
      > => {
      return useMutation(getUpdateSettingsMutationOptions(options));
    }