lib/api-client-react/src/generated/api.ts

/**
 * Generated by orval v8.9.1 🍺
 * Do not edit manually.
 * Api
 * Io HST Search Engine 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 {
  FeedbackInput,
  FeedbackResult,
  FeedbackStats,
  FineTuneInput,
  FineTuneState,
  HealthStatus,
  ModelInput,
  ModelResult,
  ModelStatus,
  SearchInput,
  SearchResult
} from './api.schemas';

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

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

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


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



export const getHealthCheckUrl = () => {




  return `/api/healthz`
}

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

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


  }
);}





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


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

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

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



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





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

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


/**
 * @summary Health check
 */

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

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

  const queryOptions = getHealthCheckQueryOptions(options)

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

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







export const getSearchUrl = () => {




  return `/api/search`
}

/**
 * Runs the HST search engine across 200+ sources and returns a synthesized answer
 * @summary Search and synthesize
 */
export const search = async (searchInput: SearchInput, options?: RequestInit): Promise<SearchResult> => {

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




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

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

          return  search(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type SearchMutationResult = NonNullable<Awaited<ReturnType<typeof search>>>
    export type SearchMutationBody = BodyType<SearchInput>
    export type SearchMutationError = ErrorType<void>

    /**
 * @summary Search and synthesize
 */
export const useSearch = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof search>>, TError,{data: BodyType<SearchInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof search>>,
        TError,
        {data: BodyType<SearchInput>},
        TContext
      > => {
      return useMutation(getSearchMutationOptions(options));
    }

export const getModelGenerateUrl = () => {




  return `/api/model/generate`
}

/**
 * Runs inference on the Io HST checkpoint
 * @summary Generate text from Io neural model
 */
export const modelGenerate = async (modelInput: ModelInput, options?: RequestInit): Promise<ModelResult> => {

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




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

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

          return  modelGenerate(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type ModelGenerateMutationResult = NonNullable<Awaited<ReturnType<typeof modelGenerate>>>
    export type ModelGenerateMutationBody = BodyType<ModelInput>
    export type ModelGenerateMutationError = ErrorType<void>

    /**
 * @summary Generate text from Io neural model
 */
export const useModelGenerate = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof modelGenerate>>, TError,{data: BodyType<ModelInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof modelGenerate>>,
        TError,
        {data: BodyType<ModelInput>},
        TContext
      > => {
      return useMutation(getModelGenerateMutationOptions(options));
    }

export const getSubmitFeedbackUrl = () => {




  return `/api/feedback`
}

/**
 * @summary Submit thumbs up/down for a search answer
 */
export const submitFeedback = async (feedbackInput: FeedbackInput, options?: RequestInit): Promise<FeedbackResult> => {

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




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

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

          return  submitFeedback(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type SubmitFeedbackMutationResult = NonNullable<Awaited<ReturnType<typeof submitFeedback>>>
    export type SubmitFeedbackMutationBody = BodyType<FeedbackInput>
    export type SubmitFeedbackMutationError = ErrorType<void>

    /**
 * @summary Submit thumbs up/down for a search answer
 */
export const useSubmitFeedback = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof submitFeedback>>, TError,{data: BodyType<FeedbackInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof submitFeedback>>,
        TError,
        {data: BodyType<FeedbackInput>},
        TContext
      > => {
      return useMutation(getSubmitFeedbackMutationOptions(options));
    }

export const getFeedbackStatsUrl = () => {




  return `/api/feedback/stats`
}

/**
 * @summary Aggregate feedback stats
 */
export const feedbackStats = async ( options?: RequestInit): Promise<FeedbackStats> => {

  return customFetch<FeedbackStats>(getFeedbackStatsUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getFeedbackStatsQueryKey = () => {
    return [
    `/api/feedback/stats`
    ] as const;
    }


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

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

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



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





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

export type FeedbackStatsQueryResult = NonNullable<Awaited<ReturnType<typeof feedbackStats>>>
export type FeedbackStatsQueryError = ErrorType<unknown>


/**
 * @summary Aggregate feedback stats
 */

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

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

  const queryOptions = getFeedbackStatsQueryOptions(options)

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

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







export const getModelFineTuneUrl = () => {




  return `/api/model/finetune`
}

/**
 * @summary Start light CPU fine-tuning of the Io checkpoint
 */
export const modelFineTune = async (fineTuneInput?: FineTuneInput, options?: RequestInit): Promise<FineTuneState> => {

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




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

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

          return  modelFineTune(data,requestOptions)
        }






  return  { mutationFn, ...mutationOptions }}

    export type ModelFineTuneMutationResult = NonNullable<Awaited<ReturnType<typeof modelFineTune>>>
    export type ModelFineTuneMutationBody = BodyType<FineTuneInput> | undefined
    export type ModelFineTuneMutationError = ErrorType<void>

    /**
 * @summary Start light CPU fine-tuning of the Io checkpoint
 */
export const useModelFineTune = <TError = ErrorType<void>,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof modelFineTune>>, TError,{data?: BodyType<FineTuneInput>}, TContext>, request?: SecondParameter<typeof customFetch>}
 ): UseMutationResult<
        Awaited<ReturnType<typeof modelFineTune>>,
        TError,
        {data?: BodyType<FineTuneInput>},
        TContext
      > => {
      return useMutation(getModelFineTuneMutationOptions(options));
    }

export const getModelFineTuneStatusUrl = () => {




  return `/api/model/finetune/status`
}

/**
 * @summary Fine-tune status
 */
export const modelFineTuneStatus = async ( options?: RequestInit): Promise<FineTuneState> => {

  return customFetch<FineTuneState>(getModelFineTuneStatusUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





export const getModelFineTuneStatusQueryKey = () => {
    return [
    `/api/model/finetune/status`
    ] as const;
    }


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

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

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



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





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

export type ModelFineTuneStatusQueryResult = NonNullable<Awaited<ReturnType<typeof modelFineTuneStatus>>>
export type ModelFineTuneStatusQueryError = ErrorType<unknown>


/**
 * @summary Fine-tune status
 */

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

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

  const queryOptions = getModelFineTuneStatusQueryOptions(options)

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

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







export const getModelStatusUrl = () => {




  return `/api/model/status`
}

/**
 * @summary Model status
 */
export const modelStatus = async ( options?: RequestInit): Promise<ModelStatus> => {

  return customFetch<ModelStatus>(getModelStatusUrl(),
  {
    ...options,
    method: 'GET'


  }
);}





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


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

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

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



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





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

export type ModelStatusQueryResult = NonNullable<Awaited<ReturnType<typeof modelStatus>>>
export type ModelStatusQueryError = ErrorType<unknown>


/**
 * @summary Model status
 */

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

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

  const queryOptions = getModelStatusQueryOptions(options)

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

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