lib/api-client-react/src/generated/api.ts - main - Pandays/zeroadmin

lib/api-client-react/src/generated/api.ts
1 079 строк29 KB
pandaysq
фулл
09 июн 2026, 16:15
09 июн 2026, 16:152d74de9
/**
 * Generated by orval v8.9.1 🍺
 * Do not edit manually.
 * Api
 * ZeroAdmin platform API
 * 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 {
  AiAnalysis,
  Alert,
  DashboardSummary,
  HealthStatus,
  MetricsInput,
  Server,
  ServerInput,
  ServerMetrics,
  ServerUpdate
} from './api.schemas';

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

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

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


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



export const getHealthCheckUrl = () => {




  return `/api/healthz`
}

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

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


  }
);}





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


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

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

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



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





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

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


/**
 * @summary Health check
 */

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

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

  const queryOptions = getHealthCheckQueryOptions(options)

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

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







export const getListServersUrl = () => {




  return `/api/servers`
}

/**
 * @summary List all servers
 */
export const listServers = async ( options?: RequestInit): Promise<Server[]> => {

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


  }
);}





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


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

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

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



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





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

export type ListServersQueryResult = NonNullable<Awaited<ReturnType<typeof listServers>>>
export type ListServersQueryError = ErrorType<unknown>


/**
 * @summary List all servers
 */

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

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

  const queryOptions = getListServersQueryOptions(options)

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

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







export const getCreateServerUrl = () => {




  return `/api/servers`
}

/**
 * @summary Add a new server
 */
export const createServer = async (serverInput: ServerInput, options?: RequestInit): Promise<Server> => {

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




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

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

          return  createServer(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type CreateServerMutationResult = NonNullable<Awaited<ReturnType<typeof createServer>>>
    export type CreateServerMutationBody = BodyType<ServerInput>
    export type CreateServerMutationError = ErrorType<unknown>

    /**
 * @summary Add a new server
 */
export const useCreateServer = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createServer>>, TError,{data: BodyType<ServerInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof createServer>>,
        TError,
        {data: BodyType<ServerInput>},
        TContext
      > => {
      return useMutation(getCreateServerMutationOptions(options));
    }

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




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

/**
 * @summary Get server by ID
 */
export const getServer = async (id: number, options?: RequestInit): Promise<Server> => {

  return customFetch<Server>(getGetServerUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type GetServerQueryResult = NonNullable<Awaited<ReturnType<typeof getServer>>>
export type GetServerQueryError = ErrorType<void>


/**
 * @summary Get server by ID
 */

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

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

  const queryOptions = getGetServerQueryOptions(id,options)

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

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







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




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

/**
 * @summary Update server
 */
export const updateServer = async (id: number,
    serverUpdate: ServerUpdate, options?: RequestInit): Promise<Server> => {

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




export const getUpdateServerMutationOptions = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateServer>>, TError,{id: number;data: BodyType<ServerUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof updateServer>>, TError,{id: number;data: BodyType<ServerUpdate>}, TContext> => {

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

          return  updateServer(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type UpdateServerMutationResult = NonNullable<Awaited<ReturnType<typeof updateServer>>>
    export type UpdateServerMutationBody = BodyType<ServerUpdate>
    export type UpdateServerMutationError = ErrorType<void>

    /**
 * @summary Update server
 */
export const useUpdateServer = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateServer>>, TError,{id: number;data: BodyType<ServerUpdate>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof updateServer>>,
        TError,
        {id: number;data: BodyType<ServerUpdate>},
        TContext
      > => {
      return useMutation(getUpdateServerMutationOptions(options));
    }

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




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

/**
 * @summary Delete server
 */
export const deleteServer = async (id: number, options?: RequestInit): Promise<void> => {

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


  }
);}




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

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

          return  deleteServer(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type DeleteServerMutationResult = NonNullable<Awaited<ReturnType<typeof deleteServer>>>

    export type DeleteServerMutationError = ErrorType<void>

    /**
 * @summary Delete server
 */
export const useDeleteServer = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof deleteServer>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof deleteServer>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getDeleteServerMutationOptions(options));
    }

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




  return `/api/servers/${id}/metrics`
}

/**
 * @summary Get latest metrics for a server
 */
export const getServerMetrics = async (id: number, options?: RequestInit): Promise<ServerMetrics> => {

  return customFetch<ServerMetrics>(getGetServerMetricsUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type GetServerMetricsQueryResult = NonNullable<Awaited<ReturnType<typeof getServerMetrics>>>
export type GetServerMetricsQueryError = ErrorType<void>


/**
 * @summary Get latest metrics for a server
 */

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

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

  const queryOptions = getGetServerMetricsQueryOptions(id,options)

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

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







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




  return `/api/servers/${id}/metrics`
}

/**
 * @summary Push metrics from agent
 */
export const pushServerMetrics = async (id: number,
    metricsInput: MetricsInput, options?: RequestInit): Promise<ServerMetrics> => {

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




export const getPushServerMetricsMutationOptions = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof pushServerMetrics>>, TError,{id: number;data: BodyType<MetricsInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
): UseMutationOptions<Awaited<ReturnType<typeof pushServerMetrics>>, TError,{id: number;data: BodyType<MetricsInput>}, TContext> => {

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

          return  pushServerMetrics(id,data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type PushServerMetricsMutationResult = NonNullable<Awaited<ReturnType<typeof pushServerMetrics>>>
    export type PushServerMetricsMutationBody = BodyType<MetricsInput>
    export type PushServerMetricsMutationError = ErrorType<unknown>

    /**
 * @summary Push metrics from agent
 */
export const usePushServerMetrics = <TError = ErrorType<unknown>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof pushServerMetrics>>, TError,{id: number;data: BodyType<MetricsInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof pushServerMetrics>>,
        TError,
        {id: number;data: BodyType<MetricsInput>},
        TContext
      > => {
      return useMutation(getPushServerMetricsMutationOptions(options));
    }

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




  return `/api/servers/${id}/metrics/history`
}

/**
 * @summary Get metrics history for a server (last 60 data points)
 */
export const getMetricsHistory = async (id: number, options?: RequestInit): Promise<ServerMetrics[]> => {

  return customFetch<ServerMetrics[]>(getGetMetricsHistoryUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





export const getGetMetricsHistoryQueryKey = (id: number,) => {
    return [
    `/api/servers/${id}/metrics/history`
    ] as const;
    }


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

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

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



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





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

export type GetMetricsHistoryQueryResult = NonNullable<Awaited<ReturnType<typeof getMetricsHistory>>>
export type GetMetricsHistoryQueryError = ErrorType<unknown>


/**
 * @summary Get metrics history for a server (last 60 data points)
 */

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

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

  const queryOptions = getGetMetricsHistoryQueryOptions(id,options)

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

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







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




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

/**
 * @summary List alerts for a server
 */
export const listServerAlerts = async (id: number, options?: RequestInit): Promise<Alert[]> => {

  return customFetch<Alert[]>(getListServerAlertsUrl(id),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type ListServerAlertsQueryResult = NonNullable<Awaited<ReturnType<typeof listServerAlerts>>>
export type ListServerAlertsQueryError = ErrorType<unknown>


/**
 * @summary List alerts for a server
 */

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

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

  const queryOptions = getListServerAlertsQueryOptions(id,options)

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

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







export const getListAlertsUrl = () => {




  return `/api/alerts`
}

/**
 * @summary List all alerts
 */
export const listAlerts = async ( options?: RequestInit): Promise<Alert[]> => {

  return customFetch<Alert[]>(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 List all alerts
 */

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 { ...query, queryKey: queryOptions.queryKey };
}







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




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

/**
 * @summary Mark an alert as resolved
 */
export const resolveAlert = async (id: number, options?: RequestInit): Promise<Alert> => {

  return customFetch<Alert>(getResolveAlertUrl(id),
  {
    ...options,
    method: 'PATCH'


  }
);}




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

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

          return  resolveAlert(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type ResolveAlertMutationResult = NonNullable<Awaited<ReturnType<typeof resolveAlert>>>

    export type ResolveAlertMutationError = ErrorType<void>

    /**
 * @summary Mark an alert as resolved
 */
export const useResolveAlert = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof resolveAlert>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof resolveAlert>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getResolveAlertMutationOptions(options));
    }

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




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

/**
 * @summary Trigger AI analysis for an alert
 */
export const analyzeAlert = async (id: number, options?: RequestInit): Promise<AiAnalysis> => {

  return customFetch<AiAnalysis>(getAnalyzeAlertUrl(id),
  {
    ...options,
    method: 'POST'


  }
);}




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

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

          return  analyzeAlert(id,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type AnalyzeAlertMutationResult = NonNullable<Awaited<ReturnType<typeof analyzeAlert>>>

    export type AnalyzeAlertMutationError = ErrorType<void>

    /**
 * @summary Trigger AI analysis for an alert
 */
export const useAnalyzeAlert = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof analyzeAlert>>, TError,{id: number}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof analyzeAlert>>,
        TError,
        {id: number},
        TContext
      > => {
      return useMutation(getAnalyzeAlertMutationOptions(options));
    }

export const getGetDashboardSummaryUrl = () => {




  return `/api/dashboard/summary`
}

/**
 * @summary Dashboard summary stats
 */
export const getDashboardSummary = async ( options?: RequestInit): 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 Dashboard summary stats
 */

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 { ...query, queryKey: queryOptions.queryKey };
}