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

import type {
  AuditEvent,
  DashboardSummary,
  GetDashboardSummaryParams,
  HealthStatus,
  Layer,
  LayerInput,
  LayerUpdate,
  ListActivitiesParams,
  ShelterActivity,
  WorkspaceUser
} 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 getGetDashboardSummaryUrl = (params?: GetDashboardSummaryParams,) => {
  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/dashboard/summary?${stringifiedParams}` : `/api/dashboard/summary`
}

/**
 * @summary Get dashboard indicators and filter options
 */
export const getDashboardSummary = async (params?: GetDashboardSummaryParams, options?: Parameters<typeof customFetch>[1]): Promise<DashboardSummary> => {

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


  }
);}





export const getGetDashboardSummaryQueryKey = (params?: GetDashboardSummaryParams,) => {
    return [
    `/api/dashboard/summary`, ...(params ? [params] : [])
    ] as const;
    }


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

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

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



    const queryFn: QueryFunction<Awaited<ReturnType<typeof getDashboardSummary>>> = ({ signal }) => getDashboardSummary(params, { 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 Get dashboard indicators and filter options
 */

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

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

  const queryOptions = getGetDashboardSummaryQueryOptions(params,options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListActivitiesUrl = (params?: ListActivitiesParams,) => {
  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/dashboard/activities?${stringifiedParams}` : `/api/dashboard/activities`
}

/**
 * @summary List filtered shelter and NFI activities
 */
export const listActivities = async (params?: ListActivitiesParams, options?: Parameters<typeof customFetch>[1]): Promise<ShelterActivity[]> => {

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


  }
);}





export const getListActivitiesQueryKey = (params?: ListActivitiesParams,) => {
    return [
    `/api/dashboard/activities`, ...(params ? [params] : [])
    ] as const;
    }


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

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

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



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





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

export type ListActivitiesQueryResult = NonNullable<Awaited<ReturnType<typeof listActivities>>>
export type ListActivitiesQueryError = ErrorType<unknown>


/**
 * @summary List filtered shelter and NFI activities
 */

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

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

  const queryOptions = getListActivitiesQueryOptions(params,options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListLayersUrl = () => {




  return `/api/layers`
}

/**
 * @summary List configured map layers
 */
export const listLayers = async ( options?: Parameters<typeof customFetch>[1]): Promise<Layer[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListLayersQueryResult = NonNullable<Awaited<ReturnType<typeof listLayers>>>
export type ListLayersQueryError = ErrorType<unknown>


/**
 * @summary List configured map layers
 */

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

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

  const queryOptions = getListLayersQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getCreateLayerUrl = () => {




  return `/api/layers`
}

/**
 * @summary Create a map layer
 */
export const createLayer = async (layerInput: LayerInput, options?: Parameters<typeof customFetch>[1]): Promise<Layer> => {

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





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

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

          return  createLayer(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateLayerMutationResult = NonNullable<Awaited<ReturnType<typeof createLayer>>>
    export type CreateLayerMutationBody = BodyType<LayerInput>
    export type CreateLayerMutationError = ErrorType<unknown>

    /**
 * @summary Create a map layer
 */
export const useCreateLayer = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createLayer>>, TError,{data: BodyType<LayerInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createLayer>>,
        TError,
        {data: BodyType<LayerInput>},
        TContext
      > => {
      return useMutation(getCreateLayerMutationOptions(options));
    }

export const getUpdateLayerUrl = (layerId: number,) => {




  return `/api/layers/${layerId}`
}

/**
 * @summary Update a map layer
 */
export const updateLayer = async (layerId: number,
    layerUpdate: LayerUpdate, options?: Parameters<typeof customFetch>[1]): Promise<Layer> => {

  return customFetch<Layer>(getUpdateLayerUrl(layerId),
  {
    ...options,
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(layerUpdate)
  }
);}





export const getUpdateLayerMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateLayer>>, TError,{layerId: number;data: BodyType<LayerUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateLayer>>, TError,{layerId: number;data: BodyType<LayerUpdate>}, TContext> => {

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

          return  updateLayer(layerId,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateLayerMutationResult = NonNullable<Awaited<ReturnType<typeof updateLayer>>>
    export type UpdateLayerMutationBody = BodyType<LayerUpdate>
    export type UpdateLayerMutationError = ErrorType<unknown>

    /**
 * @summary Update a map layer
 */
export const useUpdateLayer = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateLayer>>, TError,{layerId: number;data: BodyType<LayerUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateLayer>>,
        TError,
        {layerId: number;data: BodyType<LayerUpdate>},
        TContext
      > => {
      return useMutation(getUpdateLayerMutationOptions(options));
    }

export const getListAuditLogUrl = () => {




  return `/api/admin/audit-log`
}

/**
 * @summary List recent workspace changes
 */
export const listAuditLog = async ( options?: Parameters<typeof customFetch>[1]): Promise<AuditEvent[]> => {

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


  }
);}





export const getListAuditLogQueryKey = () => {
    return [
    `/api/admin/audit-log`
    ] as const;
    }


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

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

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



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





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

export type ListAuditLogQueryResult = NonNullable<Awaited<ReturnType<typeof listAuditLog>>>
export type ListAuditLogQueryError = ErrorType<unknown>


/**
 * @summary List recent workspace changes
 */

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

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

  const queryOptions = getListAuditLogQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}







export const getListUsersUrl = () => {




  return `/api/admin/users`
}

/**
 * @summary List workspace users
 */
export const listUsers = async ( options?: Parameters<typeof customFetch>[1]): Promise<WorkspaceUser[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListUsersQueryResult = NonNullable<Awaited<ReturnType<typeof listUsers>>>
export type ListUsersQueryError = ErrorType<unknown>


/**
 * @summary List workspace users
 */

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

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

  const queryOptions = getListUsersQueryOptions(options)

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

  return withQueryKey(query, queryOptions.queryKey);
}