/**
 * Generated by orval v8.5.3 🍺
 * Do not edit manually.
 * AnthoLume API v1
 * REST API for AnthoLume document management system
 * OpenAPI spec version: 1.0.0
 */
import {
  useMutation,
  useQuery
} from '@tanstack/react-query';
import type {
  DataTag,
  DefinedInitialDataOptions,
  DefinedUseQueryResult,
  MutationFunction,
  QueryClient,
  QueryFunction,
  QueryKey,
  UndefinedInitialDataOptions,
  UseMutationOptions,
  UseMutationResult,
  UseQueryOptions,
  UseQueryResult
} from '@tanstack/react-query';

import type {
  ActivityResponse,
  CreateActivityRequest,
  CreateActivityResponse,
  CreateDocumentBody,
  DirectoryListResponse,
  DocumentResponse,
  DocumentsResponse,
  EditDocumentBody,
  ErrorResponse,
  GetActivityParams,
  GetAdmin200,
  GetDocumentsParams,
  GetImportDirectoryParams,
  GetLogsParams,
  GetProgressListParams,
  GetSearchParams,
  GraphDataResponse,
  HomeResponse,
  ImportResultsResponse,
  InfoResponse,
  LoginRequest,
  LoginResponse,
  LogsResponse,
  MessageResponse,
  PostAdminActionBody,
  PostImportBody,
  PostSearchBody,
  ProgressListResponse,
  ProgressResponse,
  SearchResponse,
  SettingsResponse,
  StreaksResponse,
  UpdateProgressRequest,
  UpdateProgressResponse,
  UpdateSettingsRequest,
  UpdateUserBody,
  UploadDocumentCoverBody,
  UserStatisticsResponse,
  UsersResponse
} from './model';





/**
 * @summary List documents
 */
export type getDocumentsResponse200 = {
  data: DocumentsResponse
  status: 200
}

export type getDocumentsResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getDocumentsResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getDocumentsResponseSuccess = (getDocumentsResponse200) & {
  headers: Headers;
};
export type getDocumentsResponseError = (getDocumentsResponse401 | getDocumentsResponse500) & {
  headers: Headers;
};

export type getDocumentsResponse = (getDocumentsResponseSuccess | getDocumentsResponseError)

export const getGetDocumentsUrl = (params?: GetDocumentsParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

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

export const getDocuments = async (params?: GetDocumentsParams, options?: RequestInit): Promise<getDocumentsResponse> => {
  
  const res = await fetch(getGetDocumentsUrl(params),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getDocumentsResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getDocumentsResponse
}
  




export const getGetDocumentsQueryKey = (params?: GetDocumentsParams,) => {
    return [
    `/api/v1/documents`, ...(params ? [params] : [])
    ] as const;
    }

    
export const getGetDocumentsQueryOptions = <TData = Awaited<ReturnType<typeof getDocuments>>, TError = ErrorResponse>(params?: GetDocumentsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocuments>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetDocumentsQueryResult = NonNullable<Awaited<ReturnType<typeof getDocuments>>>
export type GetDocumentsQueryError = ErrorResponse


export function useGetDocuments<TData = Awaited<ReturnType<typeof getDocuments>>, TError = ErrorResponse>(
 params: undefined |  GetDocumentsParams, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocuments>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocuments>>,
          TError,
          Awaited<ReturnType<typeof getDocuments>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocuments<TData = Awaited<ReturnType<typeof getDocuments>>, TError = ErrorResponse>(
 params?: GetDocumentsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocuments>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocuments>>,
          TError,
          Awaited<ReturnType<typeof getDocuments>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocuments<TData = Awaited<ReturnType<typeof getDocuments>>, TError = ErrorResponse>(
 params?: GetDocumentsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocuments>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary List documents
 */

export function useGetDocuments<TData = Awaited<ReturnType<typeof getDocuments>>, TError = ErrorResponse>(
 params?: GetDocumentsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocuments>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetDocumentsQueryOptions(params,options)

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

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





/**
 * @summary Upload a new document
 */
export type createDocumentResponse200 = {
  data: DocumentResponse
  status: 200
}

export type createDocumentResponse400 = {
  data: ErrorResponse
  status: 400
}

export type createDocumentResponse401 = {
  data: ErrorResponse
  status: 401
}

export type createDocumentResponse500 = {
  data: ErrorResponse
  status: 500
}

export type createDocumentResponseSuccess = (createDocumentResponse200) & {
  headers: Headers;
};
export type createDocumentResponseError = (createDocumentResponse400 | createDocumentResponse401 | createDocumentResponse500) & {
  headers: Headers;
};

export type createDocumentResponse = (createDocumentResponseSuccess | createDocumentResponseError)

export const getCreateDocumentUrl = () => {


  

  return `/api/v1/documents`
}

export const createDocument = async (createDocumentBody: CreateDocumentBody, options?: RequestInit): Promise<createDocumentResponse> => {
    const formData = new FormData();
formData.append(`document_file`, createDocumentBody.document_file);

  const res = await fetch(getCreateDocumentUrl(),
  {      
    ...options,
    method: 'POST'
    ,
    body: 
      formData,
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: createDocumentResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as createDocumentResponse
}
  



export const getCreateDocumentMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createDocument>>, TError,{data: CreateDocumentBody}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof createDocument>>, TError,{data: CreateDocumentBody}, TContext> => {

const mutationKey = ['createDocument'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createDocument>>, {data: CreateDocumentBody}> = (props) => {
          const {data} = props ?? {};

          return  createDocument(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type CreateDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof createDocument>>>
    export type CreateDocumentMutationBody = CreateDocumentBody
    export type CreateDocumentMutationError = ErrorResponse

    /**
 * @summary Upload a new document
 */
export const useCreateDocument = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createDocument>>, TError,{data: CreateDocumentBody}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof createDocument>>,
        TError,
        {data: CreateDocumentBody},
        TContext
      > => {
      return useMutation(getCreateDocumentMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get a single document
 */
export type getDocumentResponse200 = {
  data: DocumentResponse
  status: 200
}

export type getDocumentResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getDocumentResponse404 = {
  data: ErrorResponse
  status: 404
}

export type getDocumentResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getDocumentResponseSuccess = (getDocumentResponse200) & {
  headers: Headers;
};
export type getDocumentResponseError = (getDocumentResponse401 | getDocumentResponse404 | getDocumentResponse500) & {
  headers: Headers;
};

export type getDocumentResponse = (getDocumentResponseSuccess | getDocumentResponseError)

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


  

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

export const getDocument = async (id: string, options?: RequestInit): Promise<getDocumentResponse> => {
  
  const res = await fetch(getGetDocumentUrl(id),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getDocumentResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getDocumentResponse
}
  




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

    
export const getGetDocumentQueryOptions = <TData = Awaited<ReturnType<typeof getDocument>>, TError = ErrorResponse>(id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetDocumentQueryResult = NonNullable<Awaited<ReturnType<typeof getDocument>>>
export type GetDocumentQueryError = ErrorResponse


export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ErrorResponse>(
 id: string, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocument>>,
          TError,
          Awaited<ReturnType<typeof getDocument>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocument>>,
          TError,
          Awaited<ReturnType<typeof getDocument>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get a single document
 */

export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetDocumentQueryOptions(id,options)

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

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





/**
 * @summary Update document editable fields
 */
export type editDocumentResponse200 = {
  data: DocumentResponse
  status: 200
}

export type editDocumentResponse400 = {
  data: ErrorResponse
  status: 400
}

export type editDocumentResponse401 = {
  data: ErrorResponse
  status: 401
}

export type editDocumentResponse404 = {
  data: ErrorResponse
  status: 404
}

export type editDocumentResponse500 = {
  data: ErrorResponse
  status: 500
}

export type editDocumentResponseSuccess = (editDocumentResponse200) & {
  headers: Headers;
};
export type editDocumentResponseError = (editDocumentResponse400 | editDocumentResponse401 | editDocumentResponse404 | editDocumentResponse500) & {
  headers: Headers;
};

export type editDocumentResponse = (editDocumentResponseSuccess | editDocumentResponseError)

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


  

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

export const editDocument = async (id: string,
    editDocumentBody: EditDocumentBody, options?: RequestInit): Promise<editDocumentResponse> => {
  
  const res = await fetch(getEditDocumentUrl(id),
  {      
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      editDocumentBody,)
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: editDocumentResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as editDocumentResponse
}
  



export const getEditDocumentMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof editDocument>>, TError,{id: string;data: EditDocumentBody}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof editDocument>>, TError,{id: string;data: EditDocumentBody}, TContext> => {

const mutationKey = ['editDocument'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof editDocument>>, {id: string;data: EditDocumentBody}> = (props) => {
          const {id,data} = props ?? {};

          return  editDocument(id,data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type EditDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof editDocument>>>
    export type EditDocumentMutationBody = EditDocumentBody
    export type EditDocumentMutationError = ErrorResponse

    /**
 * @summary Update document editable fields
 */
export const useEditDocument = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof editDocument>>, TError,{id: string;data: EditDocumentBody}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof editDocument>>,
        TError,
        {id: string;data: EditDocumentBody},
        TContext
      > => {
      return useMutation(getEditDocumentMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get document cover image
 */
export type getDocumentCoverResponse200ImageJpeg = {
  data: Blob
  status: 200
}

export type getDocumentCoverResponse200ImagePng = {
  data: Blob
  status: 200
}

export type getDocumentCoverResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getDocumentCoverResponse404 = {
  data: ErrorResponse
  status: 404
}

export type getDocumentCoverResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getDocumentCoverResponseSuccess = (getDocumentCoverResponse200ImageJpeg | getDocumentCoverResponse200ImagePng) & {
  headers: Headers;
};
export type getDocumentCoverResponseError = (getDocumentCoverResponse401 | getDocumentCoverResponse404 | getDocumentCoverResponse500) & {
  headers: Headers;
};

export type getDocumentCoverResponse = (getDocumentCoverResponseSuccess | getDocumentCoverResponseError)

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


  

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

export const getDocumentCover = async (id: string, options?: RequestInit): Promise<getDocumentCoverResponse> => {
  
  const res = await fetch(getGetDocumentCoverUrl(id),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getDocumentCoverResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getDocumentCoverResponse
}
  




export const getGetDocumentCoverQueryKey = (id: string,) => {
    return [
    `/api/v1/documents/${id}/cover`
    ] as const;
    }

    
export const getGetDocumentCoverQueryOptions = <TData = Awaited<ReturnType<typeof getDocumentCover>>, TError = ErrorResponse>(id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentCover>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetDocumentCoverQueryResult = NonNullable<Awaited<ReturnType<typeof getDocumentCover>>>
export type GetDocumentCoverQueryError = ErrorResponse


export function useGetDocumentCover<TData = Awaited<ReturnType<typeof getDocumentCover>>, TError = ErrorResponse>(
 id: string, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentCover>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocumentCover>>,
          TError,
          Awaited<ReturnType<typeof getDocumentCover>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocumentCover<TData = Awaited<ReturnType<typeof getDocumentCover>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentCover>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocumentCover>>,
          TError,
          Awaited<ReturnType<typeof getDocumentCover>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocumentCover<TData = Awaited<ReturnType<typeof getDocumentCover>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentCover>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get document cover image
 */

export function useGetDocumentCover<TData = Awaited<ReturnType<typeof getDocumentCover>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentCover>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetDocumentCoverQueryOptions(id,options)

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

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





/**
 * @summary Upload document cover image
 */
export type uploadDocumentCoverResponse200 = {
  data: DocumentResponse
  status: 200
}

export type uploadDocumentCoverResponse400 = {
  data: ErrorResponse
  status: 400
}

export type uploadDocumentCoverResponse401 = {
  data: ErrorResponse
  status: 401
}

export type uploadDocumentCoverResponse404 = {
  data: ErrorResponse
  status: 404
}

export type uploadDocumentCoverResponse500 = {
  data: ErrorResponse
  status: 500
}

export type uploadDocumentCoverResponseSuccess = (uploadDocumentCoverResponse200) & {
  headers: Headers;
};
export type uploadDocumentCoverResponseError = (uploadDocumentCoverResponse400 | uploadDocumentCoverResponse401 | uploadDocumentCoverResponse404 | uploadDocumentCoverResponse500) & {
  headers: Headers;
};

export type uploadDocumentCoverResponse = (uploadDocumentCoverResponseSuccess | uploadDocumentCoverResponseError)

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


  

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

export const uploadDocumentCover = async (id: string,
    uploadDocumentCoverBody: UploadDocumentCoverBody, options?: RequestInit): Promise<uploadDocumentCoverResponse> => {
    const formData = new FormData();
formData.append(`cover_file`, uploadDocumentCoverBody.cover_file);

  const res = await fetch(getUploadDocumentCoverUrl(id),
  {      
    ...options,
    method: 'POST'
    ,
    body: 
      formData,
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: uploadDocumentCoverResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as uploadDocumentCoverResponse
}
  



export const getUploadDocumentCoverMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof uploadDocumentCover>>, TError,{id: string;data: UploadDocumentCoverBody}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof uploadDocumentCover>>, TError,{id: string;data: UploadDocumentCoverBody}, TContext> => {

const mutationKey = ['uploadDocumentCover'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof uploadDocumentCover>>, {id: string;data: UploadDocumentCoverBody}> = (props) => {
          const {id,data} = props ?? {};

          return  uploadDocumentCover(id,data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type UploadDocumentCoverMutationResult = NonNullable<Awaited<ReturnType<typeof uploadDocumentCover>>>
    export type UploadDocumentCoverMutationBody = UploadDocumentCoverBody
    export type UploadDocumentCoverMutationError = ErrorResponse

    /**
 * @summary Upload document cover image
 */
export const useUploadDocumentCover = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof uploadDocumentCover>>, TError,{id: string;data: UploadDocumentCoverBody}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof uploadDocumentCover>>,
        TError,
        {id: string;data: UploadDocumentCoverBody},
        TContext
      > => {
      return useMutation(getUploadDocumentCoverMutationOptions(options), queryClient);
    }
    
/**
 * @summary Download document file
 */
export type getDocumentFileResponse200 = {
  data: Blob
  status: 200
}

export type getDocumentFileResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getDocumentFileResponse404 = {
  data: ErrorResponse
  status: 404
}

export type getDocumentFileResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getDocumentFileResponseSuccess = (getDocumentFileResponse200) & {
  headers: Headers;
};
export type getDocumentFileResponseError = (getDocumentFileResponse401 | getDocumentFileResponse404 | getDocumentFileResponse500) & {
  headers: Headers;
};

export type getDocumentFileResponse = (getDocumentFileResponseSuccess | getDocumentFileResponseError)

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


  

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

export const getDocumentFile = async (id: string, options?: RequestInit): Promise<getDocumentFileResponse> => {
  
  const res = await fetch(getGetDocumentFileUrl(id),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getDocumentFileResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getDocumentFileResponse
}
  




export const getGetDocumentFileQueryKey = (id: string,) => {
    return [
    `/api/v1/documents/${id}/file`
    ] as const;
    }

    
export const getGetDocumentFileQueryOptions = <TData = Awaited<ReturnType<typeof getDocumentFile>>, TError = ErrorResponse>(id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentFile>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetDocumentFileQueryResult = NonNullable<Awaited<ReturnType<typeof getDocumentFile>>>
export type GetDocumentFileQueryError = ErrorResponse


export function useGetDocumentFile<TData = Awaited<ReturnType<typeof getDocumentFile>>, TError = ErrorResponse>(
 id: string, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentFile>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocumentFile>>,
          TError,
          Awaited<ReturnType<typeof getDocumentFile>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocumentFile<TData = Awaited<ReturnType<typeof getDocumentFile>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentFile>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getDocumentFile>>,
          TError,
          Awaited<ReturnType<typeof getDocumentFile>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetDocumentFile<TData = Awaited<ReturnType<typeof getDocumentFile>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentFile>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Download document file
 */

export function useGetDocumentFile<TData = Awaited<ReturnType<typeof getDocumentFile>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocumentFile>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetDocumentFileQueryOptions(id,options)

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

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





/**
 * @summary List progress records
 */
export type getProgressListResponse200 = {
  data: ProgressListResponse
  status: 200
}

export type getProgressListResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getProgressListResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getProgressListResponseSuccess = (getProgressListResponse200) & {
  headers: Headers;
};
export type getProgressListResponseError = (getProgressListResponse401 | getProgressListResponse500) & {
  headers: Headers;
};

export type getProgressListResponse = (getProgressListResponseSuccess | getProgressListResponseError)

export const getGetProgressListUrl = (params?: GetProgressListParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

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

export const getProgressList = async (params?: GetProgressListParams, options?: RequestInit): Promise<getProgressListResponse> => {
  
  const res = await fetch(getGetProgressListUrl(params),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getProgressListResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getProgressListResponse
}
  




export const getGetProgressListQueryKey = (params?: GetProgressListParams,) => {
    return [
    `/api/v1/progress`, ...(params ? [params] : [])
    ] as const;
    }

    
export const getGetProgressListQueryOptions = <TData = Awaited<ReturnType<typeof getProgressList>>, TError = ErrorResponse>(params?: GetProgressListParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgressList>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetProgressListQueryResult = NonNullable<Awaited<ReturnType<typeof getProgressList>>>
export type GetProgressListQueryError = ErrorResponse


export function useGetProgressList<TData = Awaited<ReturnType<typeof getProgressList>>, TError = ErrorResponse>(
 params: undefined |  GetProgressListParams, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgressList>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getProgressList>>,
          TError,
          Awaited<ReturnType<typeof getProgressList>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetProgressList<TData = Awaited<ReturnType<typeof getProgressList>>, TError = ErrorResponse>(
 params?: GetProgressListParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgressList>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getProgressList>>,
          TError,
          Awaited<ReturnType<typeof getProgressList>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetProgressList<TData = Awaited<ReturnType<typeof getProgressList>>, TError = ErrorResponse>(
 params?: GetProgressListParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgressList>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary List progress records
 */

export function useGetProgressList<TData = Awaited<ReturnType<typeof getProgressList>>, TError = ErrorResponse>(
 params?: GetProgressListParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgressList>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetProgressListQueryOptions(params,options)

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

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





/**
 * @summary Update document progress
 */
export type updateProgressResponse200 = {
  data: UpdateProgressResponse
  status: 200
}

export type updateProgressResponse400 = {
  data: ErrorResponse
  status: 400
}

export type updateProgressResponse401 = {
  data: ErrorResponse
  status: 401
}

export type updateProgressResponse500 = {
  data: ErrorResponse
  status: 500
}

export type updateProgressResponseSuccess = (updateProgressResponse200) & {
  headers: Headers;
};
export type updateProgressResponseError = (updateProgressResponse400 | updateProgressResponse401 | updateProgressResponse500) & {
  headers: Headers;
};

export type updateProgressResponse = (updateProgressResponseSuccess | updateProgressResponseError)

export const getUpdateProgressUrl = () => {


  

  return `/api/v1/progress`
}

export const updateProgress = async (updateProgressRequest: UpdateProgressRequest, options?: RequestInit): Promise<updateProgressResponse> => {
  
  const res = await fetch(getUpdateProgressUrl(),
  {      
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      updateProgressRequest,)
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: updateProgressResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as updateProgressResponse
}
  



export const getUpdateProgressMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateProgress>>, TError,{data: UpdateProgressRequest}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof updateProgress>>, TError,{data: UpdateProgressRequest}, TContext> => {

const mutationKey = ['updateProgress'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateProgress>>, {data: UpdateProgressRequest}> = (props) => {
          const {data} = props ?? {};

          return  updateProgress(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type UpdateProgressMutationResult = NonNullable<Awaited<ReturnType<typeof updateProgress>>>
    export type UpdateProgressMutationBody = UpdateProgressRequest
    export type UpdateProgressMutationError = ErrorResponse

    /**
 * @summary Update document progress
 */
export const useUpdateProgress = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateProgress>>, TError,{data: UpdateProgressRequest}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof updateProgress>>,
        TError,
        {data: UpdateProgressRequest},
        TContext
      > => {
      return useMutation(getUpdateProgressMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get document progress
 */
export type getProgressResponse200 = {
  data: ProgressResponse
  status: 200
}

export type getProgressResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getProgressResponse404 = {
  data: ErrorResponse
  status: 404
}

export type getProgressResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getProgressResponseSuccess = (getProgressResponse200) & {
  headers: Headers;
};
export type getProgressResponseError = (getProgressResponse401 | getProgressResponse404 | getProgressResponse500) & {
  headers: Headers;
};

export type getProgressResponse = (getProgressResponseSuccess | getProgressResponseError)

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


  

  return `/api/v1/progress/${id}`
}

export const getProgress = async (id: string, options?: RequestInit): Promise<getProgressResponse> => {
  
  const res = await fetch(getGetProgressUrl(id),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getProgressResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getProgressResponse
}
  




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

    
export const getGetProgressQueryOptions = <TData = Awaited<ReturnType<typeof getProgress>>, TError = ErrorResponse>(id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgress>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetProgressQueryResult = NonNullable<Awaited<ReturnType<typeof getProgress>>>
export type GetProgressQueryError = ErrorResponse


export function useGetProgress<TData = Awaited<ReturnType<typeof getProgress>>, TError = ErrorResponse>(
 id: string, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgress>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getProgress>>,
          TError,
          Awaited<ReturnType<typeof getProgress>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetProgress<TData = Awaited<ReturnType<typeof getProgress>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgress>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getProgress>>,
          TError,
          Awaited<ReturnType<typeof getProgress>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetProgress<TData = Awaited<ReturnType<typeof getProgress>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgress>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get document progress
 */

export function useGetProgress<TData = Awaited<ReturnType<typeof getProgress>>, TError = ErrorResponse>(
 id: string, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getProgress>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetProgressQueryOptions(id,options)

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

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





/**
 * @summary Get activity data
 */
export type getActivityResponse200 = {
  data: ActivityResponse
  status: 200
}

export type getActivityResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getActivityResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getActivityResponseSuccess = (getActivityResponse200) & {
  headers: Headers;
};
export type getActivityResponseError = (getActivityResponse401 | getActivityResponse500) & {
  headers: Headers;
};

export type getActivityResponse = (getActivityResponseSuccess | getActivityResponseError)

export const getGetActivityUrl = (params?: GetActivityParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

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

export const getActivity = async (params?: GetActivityParams, options?: RequestInit): Promise<getActivityResponse> => {
  
  const res = await fetch(getGetActivityUrl(params),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getActivityResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getActivityResponse
}
  




export const getGetActivityQueryKey = (params?: GetActivityParams,) => {
    return [
    `/api/v1/activity`, ...(params ? [params] : [])
    ] as const;
    }

    
export const getGetActivityQueryOptions = <TData = Awaited<ReturnType<typeof getActivity>>, TError = ErrorResponse>(params?: GetActivityParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getActivity>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetActivityQueryResult = NonNullable<Awaited<ReturnType<typeof getActivity>>>
export type GetActivityQueryError = ErrorResponse


export function useGetActivity<TData = Awaited<ReturnType<typeof getActivity>>, TError = ErrorResponse>(
 params: undefined |  GetActivityParams, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getActivity>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getActivity>>,
          TError,
          Awaited<ReturnType<typeof getActivity>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetActivity<TData = Awaited<ReturnType<typeof getActivity>>, TError = ErrorResponse>(
 params?: GetActivityParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getActivity>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getActivity>>,
          TError,
          Awaited<ReturnType<typeof getActivity>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetActivity<TData = Awaited<ReturnType<typeof getActivity>>, TError = ErrorResponse>(
 params?: GetActivityParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getActivity>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get activity data
 */

export function useGetActivity<TData = Awaited<ReturnType<typeof getActivity>>, TError = ErrorResponse>(
 params?: GetActivityParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getActivity>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetActivityQueryOptions(params,options)

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

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





/**
 * @summary Create activity records
 */
export type createActivityResponse200 = {
  data: CreateActivityResponse
  status: 200
}

export type createActivityResponse400 = {
  data: ErrorResponse
  status: 400
}

export type createActivityResponse401 = {
  data: ErrorResponse
  status: 401
}

export type createActivityResponse500 = {
  data: ErrorResponse
  status: 500
}

export type createActivityResponseSuccess = (createActivityResponse200) & {
  headers: Headers;
};
export type createActivityResponseError = (createActivityResponse400 | createActivityResponse401 | createActivityResponse500) & {
  headers: Headers;
};

export type createActivityResponse = (createActivityResponseSuccess | createActivityResponseError)

export const getCreateActivityUrl = () => {


  

  return `/api/v1/activity`
}

export const createActivity = async (createActivityRequest: CreateActivityRequest, options?: RequestInit): Promise<createActivityResponse> => {
  
  const res = await fetch(getCreateActivityUrl(),
  {      
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      createActivityRequest,)
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: createActivityResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as createActivityResponse
}
  



export const getCreateActivityMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createActivity>>, TError,{data: CreateActivityRequest}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof createActivity>>, TError,{data: CreateActivityRequest}, TContext> => {

const mutationKey = ['createActivity'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof createActivity>>, {data: CreateActivityRequest}> = (props) => {
          const {data} = props ?? {};

          return  createActivity(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type CreateActivityMutationResult = NonNullable<Awaited<ReturnType<typeof createActivity>>>
    export type CreateActivityMutationBody = CreateActivityRequest
    export type CreateActivityMutationError = ErrorResponse

    /**
 * @summary Create activity records
 */
export const useCreateActivity = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof createActivity>>, TError,{data: CreateActivityRequest}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof createActivity>>,
        TError,
        {data: CreateActivityRequest},
        TContext
      > => {
      return useMutation(getCreateActivityMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get user settings
 */
export type getSettingsResponse200 = {
  data: SettingsResponse
  status: 200
}

export type getSettingsResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getSettingsResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getSettingsResponseSuccess = (getSettingsResponse200) & {
  headers: Headers;
};
export type getSettingsResponseError = (getSettingsResponse401 | getSettingsResponse500) & {
  headers: Headers;
};

export type getSettingsResponse = (getSettingsResponseSuccess | getSettingsResponseError)

export const getGetSettingsUrl = () => {


  

  return `/api/v1/settings`
}

export const getSettings = async ( options?: RequestInit): Promise<getSettingsResponse> => {
  
  const res = await fetch(getGetSettingsUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getSettingsResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getSettingsResponse
}
  




export const getGetSettingsQueryKey = () => {
    return [
    `/api/v1/settings`
    ] as const;
    }

    
export const getGetSettingsQueryOptions = <TData = Awaited<ReturnType<typeof getSettings>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSettings>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetSettingsQueryResult = NonNullable<Awaited<ReturnType<typeof getSettings>>>
export type GetSettingsQueryError = ErrorResponse


export function useGetSettings<TData = Awaited<ReturnType<typeof getSettings>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSettings>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getSettings>>,
          TError,
          Awaited<ReturnType<typeof getSettings>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetSettings<TData = Awaited<ReturnType<typeof getSettings>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSettings>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getSettings>>,
          TError,
          Awaited<ReturnType<typeof getSettings>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetSettings<TData = Awaited<ReturnType<typeof getSettings>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSettings>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get user settings
 */

export function useGetSettings<TData = Awaited<ReturnType<typeof getSettings>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSettings>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetSettingsQueryOptions(options)

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

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





/**
 * @summary Update user settings
 */
export type updateSettingsResponse200 = {
  data: SettingsResponse
  status: 200
}

export type updateSettingsResponse400 = {
  data: ErrorResponse
  status: 400
}

export type updateSettingsResponse401 = {
  data: ErrorResponse
  status: 401
}

export type updateSettingsResponse500 = {
  data: ErrorResponse
  status: 500
}

export type updateSettingsResponseSuccess = (updateSettingsResponse200) & {
  headers: Headers;
};
export type updateSettingsResponseError = (updateSettingsResponse400 | updateSettingsResponse401 | updateSettingsResponse500) & {
  headers: Headers;
};

export type updateSettingsResponse = (updateSettingsResponseSuccess | updateSettingsResponseError)

export const getUpdateSettingsUrl = () => {


  

  return `/api/v1/settings`
}

export const updateSettings = async (updateSettingsRequest: UpdateSettingsRequest, options?: RequestInit): Promise<updateSettingsResponse> => {
  
  const res = await fetch(getUpdateSettingsUrl(),
  {      
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      updateSettingsRequest,)
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: updateSettingsResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as updateSettingsResponse
}
  



export const getUpdateSettingsMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateSettings>>, TError,{data: UpdateSettingsRequest}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof updateSettings>>, TError,{data: UpdateSettingsRequest}, TContext> => {

const mutationKey = ['updateSettings'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateSettings>>, {data: UpdateSettingsRequest}> = (props) => {
          const {data} = props ?? {};

          return  updateSettings(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type UpdateSettingsMutationResult = NonNullable<Awaited<ReturnType<typeof updateSettings>>>
    export type UpdateSettingsMutationBody = UpdateSettingsRequest
    export type UpdateSettingsMutationError = ErrorResponse

    /**
 * @summary Update user settings
 */
export const useUpdateSettings = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateSettings>>, TError,{data: UpdateSettingsRequest}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof updateSettings>>,
        TError,
        {data: UpdateSettingsRequest},
        TContext
      > => {
      return useMutation(getUpdateSettingsMutationOptions(options), queryClient);
    }
    
/**
 * @summary User login
 */
export type loginResponse200 = {
  data: LoginResponse
  status: 200
}

export type loginResponse400 = {
  data: ErrorResponse
  status: 400
}

export type loginResponse401 = {
  data: ErrorResponse
  status: 401
}

export type loginResponse500 = {
  data: ErrorResponse
  status: 500
}

export type loginResponseSuccess = (loginResponse200) & {
  headers: Headers;
};
export type loginResponseError = (loginResponse400 | loginResponse401 | loginResponse500) & {
  headers: Headers;
};

export type loginResponse = (loginResponseSuccess | loginResponseError)

export const getLoginUrl = () => {


  

  return `/api/v1/auth/login`
}

export const login = async (loginRequest: LoginRequest, options?: RequestInit): Promise<loginResponse> => {
  
  const res = await fetch(getLoginUrl(),
  {      
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      loginRequest,)
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: loginResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as loginResponse
}
  



export const getLoginMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof login>>, TError,{data: LoginRequest}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof login>>, TError,{data: LoginRequest}, TContext> => {

const mutationKey = ['login'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof login>>, {data: LoginRequest}> = (props) => {
          const {data} = props ?? {};

          return  login(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type LoginMutationResult = NonNullable<Awaited<ReturnType<typeof login>>>
    export type LoginMutationBody = LoginRequest
    export type LoginMutationError = ErrorResponse

    /**
 * @summary User login
 */
export const useLogin = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof login>>, TError,{data: LoginRequest}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof login>>,
        TError,
        {data: LoginRequest},
        TContext
      > => {
      return useMutation(getLoginMutationOptions(options), queryClient);
    }
    
/**
 * @summary User registration
 */
export type registerResponse201 = {
  data: LoginResponse
  status: 201
}

export type registerResponse400 = {
  data: ErrorResponse
  status: 400
}

export type registerResponse403 = {
  data: ErrorResponse
  status: 403
}

export type registerResponse500 = {
  data: ErrorResponse
  status: 500
}

export type registerResponseSuccess = (registerResponse201) & {
  headers: Headers;
};
export type registerResponseError = (registerResponse400 | registerResponse403 | registerResponse500) & {
  headers: Headers;
};

export type registerResponse = (registerResponseSuccess | registerResponseError)

export const getRegisterUrl = () => {


  

  return `/api/v1/auth/register`
}

export const register = async (loginRequest: LoginRequest, options?: RequestInit): Promise<registerResponse> => {
  
  const res = await fetch(getRegisterUrl(),
  {      
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...options?.headers },
    body: JSON.stringify(
      loginRequest,)
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: registerResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as registerResponse
}
  



export const getRegisterMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof register>>, TError,{data: LoginRequest}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof register>>, TError,{data: LoginRequest}, TContext> => {

const mutationKey = ['register'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof register>>, {data: LoginRequest}> = (props) => {
          const {data} = props ?? {};

          return  register(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type RegisterMutationResult = NonNullable<Awaited<ReturnType<typeof register>>>
    export type RegisterMutationBody = LoginRequest
    export type RegisterMutationError = ErrorResponse

    /**
 * @summary User registration
 */
export const useRegister = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof register>>, TError,{data: LoginRequest}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof register>>,
        TError,
        {data: LoginRequest},
        TContext
      > => {
      return useMutation(getRegisterMutationOptions(options), queryClient);
    }
    
/**
 * @summary User logout
 */
export type logoutResponse200 = {
  data: void
  status: 200
}

export type logoutResponse401 = {
  data: ErrorResponse
  status: 401
}

export type logoutResponseSuccess = (logoutResponse200) & {
  headers: Headers;
};
export type logoutResponseError = (logoutResponse401) & {
  headers: Headers;
};

export type logoutResponse = (logoutResponseSuccess | logoutResponseError)

export const getLogoutUrl = () => {


  

  return `/api/v1/auth/logout`
}

export const logout = async ( options?: RequestInit): Promise<logoutResponse> => {
  
  const res = await fetch(getLogoutUrl(),
  {      
    ...options,
    method: 'POST'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: logoutResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as logoutResponse
}
  



export const getLogoutMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError,void, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError,void, TContext> => {

const mutationKey = ['logout'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof logout>>, void> = () => {
          

          return  logout(fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

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

    /**
 * @summary User logout
 */
export const useLogout = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError,void, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof logout>>,
        TError,
        void,
        TContext
      > => {
      return useMutation(getLogoutMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get current user info
 */
export type getMeResponse200 = {
  data: LoginResponse
  status: 200
}

export type getMeResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getMeResponseSuccess = (getMeResponse200) & {
  headers: Headers;
};
export type getMeResponseError = (getMeResponse401) & {
  headers: Headers;
};

export type getMeResponse = (getMeResponseSuccess | getMeResponseError)

export const getGetMeUrl = () => {


  

  return `/api/v1/auth/me`
}

export const getMe = async ( options?: RequestInit): Promise<getMeResponse> => {
  
  const res = await fetch(getGetMeUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getMeResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getMeResponse
}
  




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

    
export const getGetMeQueryOptions = <TData = Awaited<ReturnType<typeof getMe>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetMeQueryResult = NonNullable<Awaited<ReturnType<typeof getMe>>>
export type GetMeQueryError = ErrorResponse


export function useGetMe<TData = Awaited<ReturnType<typeof getMe>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getMe>>,
          TError,
          Awaited<ReturnType<typeof getMe>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetMe<TData = Awaited<ReturnType<typeof getMe>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getMe>>,
          TError,
          Awaited<ReturnType<typeof getMe>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetMe<TData = Awaited<ReturnType<typeof getMe>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get current user info
 */

export function useGetMe<TData = Awaited<ReturnType<typeof getMe>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getMe>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetMeQueryOptions(options)

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

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





/**
 * @summary Get server information
 */
export type getInfoResponse200 = {
  data: InfoResponse
  status: 200
}

export type getInfoResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getInfoResponseSuccess = (getInfoResponse200) & {
  headers: Headers;
};
export type getInfoResponseError = (getInfoResponse500) & {
  headers: Headers;
};

export type getInfoResponse = (getInfoResponseSuccess | getInfoResponseError)

export const getGetInfoUrl = () => {


  

  return `/api/v1/info`
}

export const getInfo = async ( options?: RequestInit): Promise<getInfoResponse> => {
  
  const res = await fetch(getGetInfoUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getInfoResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getInfoResponse
}
  




export const getGetInfoQueryKey = () => {
    return [
    `/api/v1/info`
    ] as const;
    }

    
export const getGetInfoQueryOptions = <TData = Awaited<ReturnType<typeof getInfo>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getInfo>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetInfoQueryResult = NonNullable<Awaited<ReturnType<typeof getInfo>>>
export type GetInfoQueryError = ErrorResponse


export function useGetInfo<TData = Awaited<ReturnType<typeof getInfo>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getInfo>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getInfo>>,
          TError,
          Awaited<ReturnType<typeof getInfo>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetInfo<TData = Awaited<ReturnType<typeof getInfo>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getInfo>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getInfo>>,
          TError,
          Awaited<ReturnType<typeof getInfo>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetInfo<TData = Awaited<ReturnType<typeof getInfo>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getInfo>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get server information
 */

export function useGetInfo<TData = Awaited<ReturnType<typeof getInfo>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getInfo>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetInfoQueryOptions(options)

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

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





/**
 * @summary Get home page data
 */
export type getHomeResponse200 = {
  data: HomeResponse
  status: 200
}

export type getHomeResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getHomeResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getHomeResponseSuccess = (getHomeResponse200) & {
  headers: Headers;
};
export type getHomeResponseError = (getHomeResponse401 | getHomeResponse500) & {
  headers: Headers;
};

export type getHomeResponse = (getHomeResponseSuccess | getHomeResponseError)

export const getGetHomeUrl = () => {


  

  return `/api/v1/home`
}

export const getHome = async ( options?: RequestInit): Promise<getHomeResponse> => {
  
  const res = await fetch(getGetHomeUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getHomeResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getHomeResponse
}
  




export const getGetHomeQueryKey = () => {
    return [
    `/api/v1/home`
    ] as const;
    }

    
export const getGetHomeQueryOptions = <TData = Awaited<ReturnType<typeof getHome>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getHome>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetHomeQueryResult = NonNullable<Awaited<ReturnType<typeof getHome>>>
export type GetHomeQueryError = ErrorResponse


export function useGetHome<TData = Awaited<ReturnType<typeof getHome>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getHome>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getHome>>,
          TError,
          Awaited<ReturnType<typeof getHome>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetHome<TData = Awaited<ReturnType<typeof getHome>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getHome>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getHome>>,
          TError,
          Awaited<ReturnType<typeof getHome>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetHome<TData = Awaited<ReturnType<typeof getHome>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getHome>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get home page data
 */

export function useGetHome<TData = Awaited<ReturnType<typeof getHome>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getHome>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetHomeQueryOptions(options)

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

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





/**
 * @summary Get user streaks
 */
export type getStreaksResponse200 = {
  data: StreaksResponse
  status: 200
}

export type getStreaksResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getStreaksResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getStreaksResponseSuccess = (getStreaksResponse200) & {
  headers: Headers;
};
export type getStreaksResponseError = (getStreaksResponse401 | getStreaksResponse500) & {
  headers: Headers;
};

export type getStreaksResponse = (getStreaksResponseSuccess | getStreaksResponseError)

export const getGetStreaksUrl = () => {


  

  return `/api/v1/home/streaks`
}

export const getStreaks = async ( options?: RequestInit): Promise<getStreaksResponse> => {
  
  const res = await fetch(getGetStreaksUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getStreaksResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getStreaksResponse
}
  




export const getGetStreaksQueryKey = () => {
    return [
    `/api/v1/home/streaks`
    ] as const;
    }

    
export const getGetStreaksQueryOptions = <TData = Awaited<ReturnType<typeof getStreaks>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getStreaks>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetStreaksQueryResult = NonNullable<Awaited<ReturnType<typeof getStreaks>>>
export type GetStreaksQueryError = ErrorResponse


export function useGetStreaks<TData = Awaited<ReturnType<typeof getStreaks>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getStreaks>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getStreaks>>,
          TError,
          Awaited<ReturnType<typeof getStreaks>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetStreaks<TData = Awaited<ReturnType<typeof getStreaks>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getStreaks>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getStreaks>>,
          TError,
          Awaited<ReturnType<typeof getStreaks>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetStreaks<TData = Awaited<ReturnType<typeof getStreaks>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getStreaks>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get user streaks
 */

export function useGetStreaks<TData = Awaited<ReturnType<typeof getStreaks>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getStreaks>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetStreaksQueryOptions(options)

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

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





/**
 * @summary Get daily read stats graph data
 */
export type getGraphDataResponse200 = {
  data: GraphDataResponse
  status: 200
}

export type getGraphDataResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getGraphDataResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getGraphDataResponseSuccess = (getGraphDataResponse200) & {
  headers: Headers;
};
export type getGraphDataResponseError = (getGraphDataResponse401 | getGraphDataResponse500) & {
  headers: Headers;
};

export type getGraphDataResponse = (getGraphDataResponseSuccess | getGraphDataResponseError)

export const getGetGraphDataUrl = () => {


  

  return `/api/v1/home/graph`
}

export const getGraphData = async ( options?: RequestInit): Promise<getGraphDataResponse> => {
  
  const res = await fetch(getGetGraphDataUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getGraphDataResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getGraphDataResponse
}
  




export const getGetGraphDataQueryKey = () => {
    return [
    `/api/v1/home/graph`
    ] as const;
    }

    
export const getGetGraphDataQueryOptions = <TData = Awaited<ReturnType<typeof getGraphData>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getGraphData>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetGraphDataQueryResult = NonNullable<Awaited<ReturnType<typeof getGraphData>>>
export type GetGraphDataQueryError = ErrorResponse


export function useGetGraphData<TData = Awaited<ReturnType<typeof getGraphData>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getGraphData>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getGraphData>>,
          TError,
          Awaited<ReturnType<typeof getGraphData>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetGraphData<TData = Awaited<ReturnType<typeof getGraphData>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getGraphData>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getGraphData>>,
          TError,
          Awaited<ReturnType<typeof getGraphData>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetGraphData<TData = Awaited<ReturnType<typeof getGraphData>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getGraphData>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get daily read stats graph data
 */

export function useGetGraphData<TData = Awaited<ReturnType<typeof getGraphData>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getGraphData>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetGraphDataQueryOptions(options)

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

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





/**
 * @summary Get user statistics (leaderboards)
 */
export type getUserStatisticsResponse200 = {
  data: UserStatisticsResponse
  status: 200
}

export type getUserStatisticsResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getUserStatisticsResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getUserStatisticsResponseSuccess = (getUserStatisticsResponse200) & {
  headers: Headers;
};
export type getUserStatisticsResponseError = (getUserStatisticsResponse401 | getUserStatisticsResponse500) & {
  headers: Headers;
};

export type getUserStatisticsResponse = (getUserStatisticsResponseSuccess | getUserStatisticsResponseError)

export const getGetUserStatisticsUrl = () => {


  

  return `/api/v1/home/statistics`
}

export const getUserStatistics = async ( options?: RequestInit): Promise<getUserStatisticsResponse> => {
  
  const res = await fetch(getGetUserStatisticsUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getUserStatisticsResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getUserStatisticsResponse
}
  




export const getGetUserStatisticsQueryKey = () => {
    return [
    `/api/v1/home/statistics`
    ] as const;
    }

    
export const getGetUserStatisticsQueryOptions = <TData = Awaited<ReturnType<typeof getUserStatistics>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUserStatistics>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetUserStatisticsQueryResult = NonNullable<Awaited<ReturnType<typeof getUserStatistics>>>
export type GetUserStatisticsQueryError = ErrorResponse


export function useGetUserStatistics<TData = Awaited<ReturnType<typeof getUserStatistics>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUserStatistics>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getUserStatistics>>,
          TError,
          Awaited<ReturnType<typeof getUserStatistics>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetUserStatistics<TData = Awaited<ReturnType<typeof getUserStatistics>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUserStatistics>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getUserStatistics>>,
          TError,
          Awaited<ReturnType<typeof getUserStatistics>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetUserStatistics<TData = Awaited<ReturnType<typeof getUserStatistics>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUserStatistics>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get user statistics (leaderboards)
 */

export function useGetUserStatistics<TData = Awaited<ReturnType<typeof getUserStatistics>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUserStatistics>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetUserStatisticsQueryOptions(options)

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

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





/**
 * @summary Search external book sources
 */
export type getSearchResponse200 = {
  data: SearchResponse
  status: 200
}

export type getSearchResponse400 = {
  data: ErrorResponse
  status: 400
}

export type getSearchResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getSearchResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getSearchResponseSuccess = (getSearchResponse200) & {
  headers: Headers;
};
export type getSearchResponseError = (getSearchResponse400 | getSearchResponse401 | getSearchResponse500) & {
  headers: Headers;
};

export type getSearchResponse = (getSearchResponseSuccess | getSearchResponseError)

export const getGetSearchUrl = (params: GetSearchParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

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

export const getSearch = async (params: GetSearchParams, options?: RequestInit): Promise<getSearchResponse> => {
  
  const res = await fetch(getGetSearchUrl(params),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getSearchResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getSearchResponse
}
  




export const getGetSearchQueryKey = (params?: GetSearchParams,) => {
    return [
    `/api/v1/search`, ...(params ? [params] : [])
    ] as const;
    }

    
export const getGetSearchQueryOptions = <TData = Awaited<ReturnType<typeof getSearch>>, TError = ErrorResponse>(params: GetSearchParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSearch>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetSearchQueryResult = NonNullable<Awaited<ReturnType<typeof getSearch>>>
export type GetSearchQueryError = ErrorResponse


export function useGetSearch<TData = Awaited<ReturnType<typeof getSearch>>, TError = ErrorResponse>(
 params: GetSearchParams, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSearch>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getSearch>>,
          TError,
          Awaited<ReturnType<typeof getSearch>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetSearch<TData = Awaited<ReturnType<typeof getSearch>>, TError = ErrorResponse>(
 params: GetSearchParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSearch>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getSearch>>,
          TError,
          Awaited<ReturnType<typeof getSearch>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetSearch<TData = Awaited<ReturnType<typeof getSearch>>, TError = ErrorResponse>(
 params: GetSearchParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSearch>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Search external book sources
 */

export function useGetSearch<TData = Awaited<ReturnType<typeof getSearch>>, TError = ErrorResponse>(
 params: GetSearchParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getSearch>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetSearchQueryOptions(params,options)

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

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





/**
 * @summary Download search result
 */
export type postSearchResponse200 = {
  data: void
  status: 200
}

export type postSearchResponse401 = {
  data: ErrorResponse
  status: 401
}

export type postSearchResponse500 = {
  data: ErrorResponse
  status: 500
}

export type postSearchResponseSuccess = (postSearchResponse200) & {
  headers: Headers;
};
export type postSearchResponseError = (postSearchResponse401 | postSearchResponse500) & {
  headers: Headers;
};

export type postSearchResponse = (postSearchResponseSuccess | postSearchResponseError)

export const getPostSearchUrl = () => {


  

  return `/api/v1/search`
}

export const postSearch = async (postSearchBody: PostSearchBody, options?: RequestInit): Promise<postSearchResponse> => {
    const formUrlEncoded = new URLSearchParams();
formUrlEncoded.append(`source`, postSearchBody.source);
formUrlEncoded.append(`title`, postSearchBody.title);
formUrlEncoded.append(`author`, postSearchBody.author);
formUrlEncoded.append(`id`, postSearchBody.id);

  const res = await fetch(getPostSearchUrl(),
  {      
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded', ...options?.headers },
    body: 
      formUrlEncoded,
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: postSearchResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as postSearchResponse
}
  



export const getPostSearchMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof postSearch>>, TError,{data: PostSearchBody}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof postSearch>>, TError,{data: PostSearchBody}, TContext> => {

const mutationKey = ['postSearch'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof postSearch>>, {data: PostSearchBody}> = (props) => {
          const {data} = props ?? {};

          return  postSearch(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type PostSearchMutationResult = NonNullable<Awaited<ReturnType<typeof postSearch>>>
    export type PostSearchMutationBody = PostSearchBody
    export type PostSearchMutationError = ErrorResponse

    /**
 * @summary Download search result
 */
export const usePostSearch = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof postSearch>>, TError,{data: PostSearchBody}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof postSearch>>,
        TError,
        {data: PostSearchBody},
        TContext
      > => {
      return useMutation(getPostSearchMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get admin page data
 */
export type getAdminResponse200 = {
  data: GetAdmin200
  status: 200
}

export type getAdminResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getAdminResponseSuccess = (getAdminResponse200) & {
  headers: Headers;
};
export type getAdminResponseError = (getAdminResponse401) & {
  headers: Headers;
};

export type getAdminResponse = (getAdminResponseSuccess | getAdminResponseError)

export const getGetAdminUrl = () => {


  

  return `/api/v1/admin`
}

export const getAdmin = async ( options?: RequestInit): Promise<getAdminResponse> => {
  
  const res = await fetch(getGetAdminUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getAdminResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getAdminResponse
}
  




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

    
export const getGetAdminQueryOptions = <TData = Awaited<ReturnType<typeof getAdmin>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAdmin>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetAdminQueryResult = NonNullable<Awaited<ReturnType<typeof getAdmin>>>
export type GetAdminQueryError = ErrorResponse


export function useGetAdmin<TData = Awaited<ReturnType<typeof getAdmin>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAdmin>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getAdmin>>,
          TError,
          Awaited<ReturnType<typeof getAdmin>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetAdmin<TData = Awaited<ReturnType<typeof getAdmin>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAdmin>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getAdmin>>,
          TError,
          Awaited<ReturnType<typeof getAdmin>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetAdmin<TData = Awaited<ReturnType<typeof getAdmin>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAdmin>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get admin page data
 */

export function useGetAdmin<TData = Awaited<ReturnType<typeof getAdmin>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getAdmin>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetAdminQueryOptions(options)

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

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





/**
 * @summary Perform admin action (backup, restore, etc.)
 */
export type postAdminActionResponse200ApplicationJson = {
  data: MessageResponse
  status: 200
}

export type postAdminActionResponse200ApplicationOctetStream = {
  data: Blob
  status: 200
}

export type postAdminActionResponse400 = {
  data: ErrorResponse
  status: 400
}

export type postAdminActionResponse401 = {
  data: ErrorResponse
  status: 401
}

export type postAdminActionResponse500 = {
  data: ErrorResponse
  status: 500
}

export type postAdminActionResponseSuccess = (postAdminActionResponse200ApplicationJson | postAdminActionResponse200ApplicationOctetStream) & {
  headers: Headers;
};
export type postAdminActionResponseError = (postAdminActionResponse400 | postAdminActionResponse401 | postAdminActionResponse500) & {
  headers: Headers;
};

export type postAdminActionResponse = (postAdminActionResponseSuccess | postAdminActionResponseError)

export const getPostAdminActionUrl = () => {


  

  return `/api/v1/admin`
}

export const postAdminAction = async (postAdminActionBody: PostAdminActionBody, options?: RequestInit): Promise<postAdminActionResponse> => {
    const formData = new FormData();
formData.append(`action`, postAdminActionBody.action);
if(postAdminActionBody.backup_types !== undefined) {
 postAdminActionBody.backup_types.forEach(value => formData.append(`backup_types`, value));
 }
if(postAdminActionBody.restore_file !== undefined) {
 formData.append(`restore_file`, postAdminActionBody.restore_file);
 }

  const res = await fetch(getPostAdminActionUrl(),
  {      
    ...options,
    method: 'POST'
    ,
    body: 
      formData,
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: postAdminActionResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as postAdminActionResponse
}
  



export const getPostAdminActionMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof postAdminAction>>, TError,{data: PostAdminActionBody}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof postAdminAction>>, TError,{data: PostAdminActionBody}, TContext> => {

const mutationKey = ['postAdminAction'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof postAdminAction>>, {data: PostAdminActionBody}> = (props) => {
          const {data} = props ?? {};

          return  postAdminAction(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type PostAdminActionMutationResult = NonNullable<Awaited<ReturnType<typeof postAdminAction>>>
    export type PostAdminActionMutationBody = PostAdminActionBody
    export type PostAdminActionMutationError = ErrorResponse

    /**
 * @summary Perform admin action (backup, restore, etc.)
 */
export const usePostAdminAction = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof postAdminAction>>, TError,{data: PostAdminActionBody}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof postAdminAction>>,
        TError,
        {data: PostAdminActionBody},
        TContext
      > => {
      return useMutation(getPostAdminActionMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get all users
 */
export type getUsersResponse200 = {
  data: UsersResponse
  status: 200
}

export type getUsersResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getUsersResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getUsersResponseSuccess = (getUsersResponse200) & {
  headers: Headers;
};
export type getUsersResponseError = (getUsersResponse401 | getUsersResponse500) & {
  headers: Headers;
};

export type getUsersResponse = (getUsersResponseSuccess | getUsersResponseError)

export const getGetUsersUrl = () => {


  

  return `/api/v1/admin/users`
}

export const getUsers = async ( options?: RequestInit): Promise<getUsersResponse> => {
  
  const res = await fetch(getGetUsersUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getUsersResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getUsersResponse
}
  




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

    
export const getGetUsersQueryOptions = <TData = Awaited<ReturnType<typeof getUsers>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUsers>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetUsersQueryResult = NonNullable<Awaited<ReturnType<typeof getUsers>>>
export type GetUsersQueryError = ErrorResponse


export function useGetUsers<TData = Awaited<ReturnType<typeof getUsers>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUsers>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getUsers>>,
          TError,
          Awaited<ReturnType<typeof getUsers>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetUsers<TData = Awaited<ReturnType<typeof getUsers>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUsers>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getUsers>>,
          TError,
          Awaited<ReturnType<typeof getUsers>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetUsers<TData = Awaited<ReturnType<typeof getUsers>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUsers>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get all users
 */

export function useGetUsers<TData = Awaited<ReturnType<typeof getUsers>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getUsers>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetUsersQueryOptions(options)

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

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





/**
 * @summary Create, update, or delete user
 */
export type updateUserResponse200 = {
  data: UsersResponse
  status: 200
}

export type updateUserResponse400 = {
  data: ErrorResponse
  status: 400
}

export type updateUserResponse401 = {
  data: ErrorResponse
  status: 401
}

export type updateUserResponse500 = {
  data: ErrorResponse
  status: 500
}

export type updateUserResponseSuccess = (updateUserResponse200) & {
  headers: Headers;
};
export type updateUserResponseError = (updateUserResponse400 | updateUserResponse401 | updateUserResponse500) & {
  headers: Headers;
};

export type updateUserResponse = (updateUserResponseSuccess | updateUserResponseError)

export const getUpdateUserUrl = () => {


  

  return `/api/v1/admin/users`
}

export const updateUser = async (updateUserBody: UpdateUserBody, options?: RequestInit): Promise<updateUserResponse> => {
    const formUrlEncoded = new URLSearchParams();
formUrlEncoded.append(`operation`, updateUserBody.operation);
formUrlEncoded.append(`user`, updateUserBody.user);
if(updateUserBody.password !== undefined) {
 formUrlEncoded.append(`password`, updateUserBody.password);
 }
if(updateUserBody.is_admin !== undefined) {
 formUrlEncoded.append(`is_admin`, updateUserBody.is_admin.toString())
 }

  const res = await fetch(getUpdateUserUrl(),
  {      
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded', ...options?.headers },
    body: 
      formUrlEncoded,
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: updateUserResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as updateUserResponse
}
  



export const getUpdateUserMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateUser>>, TError,{data: UpdateUserBody}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof updateUser>>, TError,{data: UpdateUserBody}, TContext> => {

const mutationKey = ['updateUser'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof updateUser>>, {data: UpdateUserBody}> = (props) => {
          const {data} = props ?? {};

          return  updateUser(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type UpdateUserMutationResult = NonNullable<Awaited<ReturnType<typeof updateUser>>>
    export type UpdateUserMutationBody = UpdateUserBody
    export type UpdateUserMutationError = ErrorResponse

    /**
 * @summary Create, update, or delete user
 */
export const useUpdateUser = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof updateUser>>, TError,{data: UpdateUserBody}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof updateUser>>,
        TError,
        {data: UpdateUserBody},
        TContext
      > => {
      return useMutation(getUpdateUserMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get import directory list
 */
export type getImportDirectoryResponse200 = {
  data: DirectoryListResponse
  status: 200
}

export type getImportDirectoryResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getImportDirectoryResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getImportDirectoryResponseSuccess = (getImportDirectoryResponse200) & {
  headers: Headers;
};
export type getImportDirectoryResponseError = (getImportDirectoryResponse401 | getImportDirectoryResponse500) & {
  headers: Headers;
};

export type getImportDirectoryResponse = (getImportDirectoryResponseSuccess | getImportDirectoryResponseError)

export const getGetImportDirectoryUrl = (params?: GetImportDirectoryParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0 ? `/api/v1/admin/import?${stringifiedParams}` : `/api/v1/admin/import`
}

export const getImportDirectory = async (params?: GetImportDirectoryParams, options?: RequestInit): Promise<getImportDirectoryResponse> => {
  
  const res = await fetch(getGetImportDirectoryUrl(params),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getImportDirectoryResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getImportDirectoryResponse
}
  




export const getGetImportDirectoryQueryKey = (params?: GetImportDirectoryParams,) => {
    return [
    `/api/v1/admin/import`, ...(params ? [params] : [])
    ] as const;
    }

    
export const getGetImportDirectoryQueryOptions = <TData = Awaited<ReturnType<typeof getImportDirectory>>, TError = ErrorResponse>(params?: GetImportDirectoryParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportDirectory>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetImportDirectoryQueryResult = NonNullable<Awaited<ReturnType<typeof getImportDirectory>>>
export type GetImportDirectoryQueryError = ErrorResponse


export function useGetImportDirectory<TData = Awaited<ReturnType<typeof getImportDirectory>>, TError = ErrorResponse>(
 params: undefined |  GetImportDirectoryParams, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportDirectory>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getImportDirectory>>,
          TError,
          Awaited<ReturnType<typeof getImportDirectory>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetImportDirectory<TData = Awaited<ReturnType<typeof getImportDirectory>>, TError = ErrorResponse>(
 params?: GetImportDirectoryParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportDirectory>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getImportDirectory>>,
          TError,
          Awaited<ReturnType<typeof getImportDirectory>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetImportDirectory<TData = Awaited<ReturnType<typeof getImportDirectory>>, TError = ErrorResponse>(
 params?: GetImportDirectoryParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportDirectory>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get import directory list
 */

export function useGetImportDirectory<TData = Awaited<ReturnType<typeof getImportDirectory>>, TError = ErrorResponse>(
 params?: GetImportDirectoryParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportDirectory>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetImportDirectoryQueryOptions(params,options)

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

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





/**
 * @summary Perform import
 */
export type postImportResponse200 = {
  data: ImportResultsResponse
  status: 200
}

export type postImportResponse400 = {
  data: ErrorResponse
  status: 400
}

export type postImportResponse401 = {
  data: ErrorResponse
  status: 401
}

export type postImportResponse500 = {
  data: ErrorResponse
  status: 500
}

export type postImportResponseSuccess = (postImportResponse200) & {
  headers: Headers;
};
export type postImportResponseError = (postImportResponse400 | postImportResponse401 | postImportResponse500) & {
  headers: Headers;
};

export type postImportResponse = (postImportResponseSuccess | postImportResponseError)

export const getPostImportUrl = () => {


  

  return `/api/v1/admin/import`
}

export const postImport = async (postImportBody: PostImportBody, options?: RequestInit): Promise<postImportResponse> => {
    const formUrlEncoded = new URLSearchParams();
formUrlEncoded.append(`directory`, postImportBody.directory);
formUrlEncoded.append(`type`, postImportBody.type);

  const res = await fetch(getPostImportUrl(),
  {      
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded', ...options?.headers },
    body: 
      formUrlEncoded,
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: postImportResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as postImportResponse
}
  



export const getPostImportMutationOptions = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof postImport>>, TError,{data: PostImportBody}, TContext>, fetch?: RequestInit}
): UseMutationOptions<Awaited<ReturnType<typeof postImport>>, TError,{data: PostImportBody}, TContext> => {

const mutationKey = ['postImport'];
const {mutation: mutationOptions, fetch: fetchOptions} = options ?
      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
      options
      : {...options, mutation: {...options.mutation, mutationKey}}
      : {mutation: { mutationKey, }, fetch: undefined};

      


      const mutationFn: MutationFunction<Awaited<ReturnType<typeof postImport>>, {data: PostImportBody}> = (props) => {
          const {data} = props ?? {};

          return  postImport(data,fetchOptions)
        }



        


  return  { mutationFn, ...mutationOptions }}

    export type PostImportMutationResult = NonNullable<Awaited<ReturnType<typeof postImport>>>
    export type PostImportMutationBody = PostImportBody
    export type PostImportMutationError = ErrorResponse

    /**
 * @summary Perform import
 */
export const usePostImport = <TError = ErrorResponse,
    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof postImport>>, TError,{data: PostImportBody}, TContext>, fetch?: RequestInit}
 , queryClient?: QueryClient): UseMutationResult<
        Awaited<ReturnType<typeof postImport>>,
        TError,
        {data: PostImportBody},
        TContext
      > => {
      return useMutation(getPostImportMutationOptions(options), queryClient);
    }
    
/**
 * @summary Get import results
 */
export type getImportResultsResponse200 = {
  data: ImportResultsResponse
  status: 200
}

export type getImportResultsResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getImportResultsResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getImportResultsResponseSuccess = (getImportResultsResponse200) & {
  headers: Headers;
};
export type getImportResultsResponseError = (getImportResultsResponse401 | getImportResultsResponse500) & {
  headers: Headers;
};

export type getImportResultsResponse = (getImportResultsResponseSuccess | getImportResultsResponseError)

export const getGetImportResultsUrl = () => {


  

  return `/api/v1/admin/import-results`
}

export const getImportResults = async ( options?: RequestInit): Promise<getImportResultsResponse> => {
  
  const res = await fetch(getGetImportResultsUrl(),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getImportResultsResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getImportResultsResponse
}
  




export const getGetImportResultsQueryKey = () => {
    return [
    `/api/v1/admin/import-results`
    ] as const;
    }

    
export const getGetImportResultsQueryOptions = <TData = Awaited<ReturnType<typeof getImportResults>>, TError = ErrorResponse>( options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportResults>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetImportResultsQueryResult = NonNullable<Awaited<ReturnType<typeof getImportResults>>>
export type GetImportResultsQueryError = ErrorResponse


export function useGetImportResults<TData = Awaited<ReturnType<typeof getImportResults>>, TError = ErrorResponse>(
  options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportResults>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getImportResults>>,
          TError,
          Awaited<ReturnType<typeof getImportResults>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetImportResults<TData = Awaited<ReturnType<typeof getImportResults>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportResults>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getImportResults>>,
          TError,
          Awaited<ReturnType<typeof getImportResults>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetImportResults<TData = Awaited<ReturnType<typeof getImportResults>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportResults>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get import results
 */

export function useGetImportResults<TData = Awaited<ReturnType<typeof getImportResults>>, TError = ErrorResponse>(
  options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getImportResults>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetImportResultsQueryOptions(options)

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

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





/**
 * @summary Get logs with optional filter
 */
export type getLogsResponse200 = {
  data: LogsResponse
  status: 200
}

export type getLogsResponse401 = {
  data: ErrorResponse
  status: 401
}

export type getLogsResponse500 = {
  data: ErrorResponse
  status: 500
}

export type getLogsResponseSuccess = (getLogsResponse200) & {
  headers: Headers;
};
export type getLogsResponseError = (getLogsResponse401 | getLogsResponse500) & {
  headers: Headers;
};

export type getLogsResponse = (getLogsResponseSuccess | getLogsResponseError)

export const getGetLogsUrl = (params?: GetLogsParams,) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : value.toString())
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0 ? `/api/v1/admin/logs?${stringifiedParams}` : `/api/v1/admin/logs`
}

export const getLogs = async (params?: GetLogsParams, options?: RequestInit): Promise<getLogsResponse> => {
  
  const res = await fetch(getGetLogsUrl(params),
  {      
    ...options,
    method: 'GET'
    
    
  }
)

  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
  
  const data: getLogsResponse['data'] = body ? JSON.parse(body) : {}
  return { data, status: res.status, headers: res.headers } as getLogsResponse
}
  




export const getGetLogsQueryKey = (params?: GetLogsParams,) => {
    return [
    `/api/v1/admin/logs`, ...(params ? [params] : [])
    ] as const;
    }

    
export const getGetLogsQueryOptions = <TData = Awaited<ReturnType<typeof getLogs>>, TError = ErrorResponse>(params?: GetLogsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getLogs>>, TError, TData>>, fetch?: RequestInit}
) => {

const {query: queryOptions, fetch: fetchOptions} = options ?? {};

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

  

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

      

      

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

export type GetLogsQueryResult = NonNullable<Awaited<ReturnType<typeof getLogs>>>
export type GetLogsQueryError = ErrorResponse


export function useGetLogs<TData = Awaited<ReturnType<typeof getLogs>>, TError = ErrorResponse>(
 params: undefined |  GetLogsParams, options: { query:Partial<UseQueryOptions<Awaited<ReturnType<typeof getLogs>>, TError, TData>> & Pick<
        DefinedInitialDataOptions<
          Awaited<ReturnType<typeof getLogs>>,
          TError,
          Awaited<ReturnType<typeof getLogs>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetLogs<TData = Awaited<ReturnType<typeof getLogs>>, TError = ErrorResponse>(
 params?: GetLogsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getLogs>>, TError, TData>> & Pick<
        UndefinedInitialDataOptions<
          Awaited<ReturnType<typeof getLogs>>,
          TError,
          Awaited<ReturnType<typeof getLogs>>
        > , 'initialData'
      >, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
export function useGetLogs<TData = Awaited<ReturnType<typeof getLogs>>, TError = ErrorResponse>(
 params?: GetLogsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getLogs>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient
  ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
/**
 * @summary Get logs with optional filter
 */

export function useGetLogs<TData = Awaited<ReturnType<typeof getLogs>>, TError = ErrorResponse>(
 params?: GetLogsParams, options?: { query?:Partial<UseQueryOptions<Awaited<ReturnType<typeof getLogs>>, TError, TData>>, fetch?: RequestInit}
 , queryClient?: QueryClient 
 ):  UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {

  const queryOptions = getGetLogsQueryOptions(params,options)

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

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