13786985073

Committed 11 Mar 2025 11:31AM CUT coverage: 66.498% (-3.4%) from 69.903%

Build # 13786985073

Build Type

Pull #368

github

Committed by

web-flow

Commit Message

Merge 58bb0179d into 583279e07

Pull Request Pull Request #368: fix: implement server side pagination in frontend

Run Details

420 of 703 branches covered (59.74%)

Branch coverage included in aggregate %.

107 of 164 new or added lines in 20 files covered. (65.24%)

13 existing lines in 5 files now uncovered.

896 of 1276 relevant lines covered (70.22%)

40.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.5

/src/api/generated/@tanstack/react-query.gen.ts

// This file is auto-generated by @hey-api/openapi-ts

import type { OptionsLegacyParser } from '@hey-api/client-fetch'
import {
  queryOptions,
  type UseMutationOptions,
  infiniteQueryOptions,
  type InfiniteData,
} from '@tanstack/react-query'
import {
  client,
  healthCheckHealthGet,
  v1ListProviderEndpoints,
  v1AddProviderEndpoint,
  v1ListAllModelsForAllProviders,
  v1ListModelsByProvider,
  v1GetProviderEndpoint,
  v1UpdateProviderEndpoint,
  v1DeleteProviderEndpoint,
  v1ConfigureAuthMaterial,
  v1ListWorkspaces,
  v1CreateWorkspace,
  v1ListActiveWorkspaces,
  v1ActivateWorkspace,
  v1UpdateWorkspace,
  v1DeleteWorkspace,
  v1ListArchivedWorkspaces,
  v1RecoverWorkspace,
  v1HardDeleteWorkspace,
  v1GetWorkspaceAlerts,
  v1GetWorkspaceAlertsSummary,
  v1GetWorkspaceMessages,
  v1GetMessagesByPromptId,
  v1GetWorkspaceCustomInstructions,
  v1SetWorkspaceCustomInstructions,
  v1DeleteWorkspaceCustomInstructions,
  v1GetWorkspaceMuxes,
  v1SetWorkspaceMuxes,
  v1ListWorkspacesByProvider,
  v1StreamSse,
  v1VersionCheck,
  v1GetWorkspaceTokenUsage,
  v1ListPersonas,
  v1CreatePersona,
  v1GetPersona,
  v1UpdatePersona,
  v1DeletePersona,
} from '../sdk.gen'
import type {
  V1ListProviderEndpointsData,
  V1AddProviderEndpointData,
  V1AddProviderEndpointError,
  V1AddProviderEndpointResponse,
  V1ListModelsByProviderData,
  V1GetProviderEndpointData,
  V1UpdateProviderEndpointData,
  V1UpdateProviderEndpointError,
  V1UpdateProviderEndpointResponse,
  V1DeleteProviderEndpointData,
  V1DeleteProviderEndpointError,
  V1DeleteProviderEndpointResponse,
  V1ConfigureAuthMaterialData,
  V1ConfigureAuthMaterialError,
  V1ConfigureAuthMaterialResponse,
  V1CreateWorkspaceData,
  V1CreateWorkspaceError,
  V1CreateWorkspaceResponse,
  V1ActivateWorkspaceData,
  V1ActivateWorkspaceError,
  V1ActivateWorkspaceResponse,
  V1UpdateWorkspaceData,
  V1UpdateWorkspaceError,
  V1UpdateWorkspaceResponse,
  V1DeleteWorkspaceData,
  V1DeleteWorkspaceError,
  V1DeleteWorkspaceResponse,
  V1RecoverWorkspaceData,
  V1RecoverWorkspaceError,
  V1RecoverWorkspaceResponse,
  V1HardDeleteWorkspaceData,
  V1HardDeleteWorkspaceError,
  V1HardDeleteWorkspaceResponse,
  V1GetWorkspaceAlertsData,
  V1GetWorkspaceAlertsSummaryData,
  V1GetWorkspaceMessagesData,
  V1GetWorkspaceMessagesError,
  V1GetWorkspaceMessagesResponse,
  V1GetMessagesByPromptIdData,
  V1GetWorkspaceCustomInstructionsData,
  V1SetWorkspaceCustomInstructionsData,
  V1SetWorkspaceCustomInstructionsError,
  V1SetWorkspaceCustomInstructionsResponse,
  V1DeleteWorkspaceCustomInstructionsData,
  V1DeleteWorkspaceCustomInstructionsError,
  V1DeleteWorkspaceCustomInstructionsResponse,
  V1GetWorkspaceMuxesData,
  V1SetWorkspaceMuxesData,
  V1SetWorkspaceMuxesError,
  V1SetWorkspaceMuxesResponse,
  V1ListWorkspacesByProviderData,
  V1GetWorkspaceTokenUsageData,
  V1CreatePersonaData,
  V1CreatePersonaError,
  V1CreatePersonaResponse,
  V1GetPersonaData,
  V1UpdatePersonaData,
  V1UpdatePersonaError,
  V1UpdatePersonaResponse,
  V1DeletePersonaData,
  V1DeletePersonaError,
  V1DeletePersonaResponse,
} from '../types.gen'

type QueryKey<TOptions extends OptionsLegacyParser> = [
  Pick<TOptions, 'baseUrl' | 'body' | 'headers' | 'path' | 'query'> & {
    _id: string
    _infinite?: boolean
  },
]

const createQueryKey = <TOptions extends OptionsLegacyParser>(
  id: string,
  options?: TOptions,
  infinite?: boolean
): QueryKey<TOptions>[0] => {
  const params: QueryKey<TOptions>[0] = {
    _id: id,
    baseUrl: (options?.client ?? client).getConfig().baseUrl,
  } as QueryKey<TOptions>[0]
  if (infinite) {
    params._infinite = infinite
  }
  if (options?.body) {
    params.body = options.body
  }
  if (options?.headers) {
    params.headers = options.headers
  }
  if (options?.path) {
    params.path = options.path
  }
  if (options?.query) {
    params.query = options.query
  }
  return params
}

export const healthCheckHealthGetQueryKey = (options?: OptionsLegacyParser) => [
  createQueryKey('healthCheckHealthGet', options),
]

export const healthCheckHealthGetOptions = (options?: OptionsLegacyParser) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await healthCheckHealthGet({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: healthCheckHealthGetQueryKey(options),
  })
}

export const v1ListProviderEndpointsQueryKey = (
  options?: OptionsLegacyParser<V1ListProviderEndpointsData>
) => [createQueryKey('v1ListProviderEndpoints', options)]

export const v1ListProviderEndpointsOptions = (
  options?: OptionsLegacyParser<V1ListProviderEndpointsData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListProviderEndpoints({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListProviderEndpointsQueryKey(options),
  })
}

export const v1AddProviderEndpointQueryKey = (
  options: OptionsLegacyParser<V1AddProviderEndpointData>
) => [createQueryKey('v1AddProviderEndpoint', options)]

export const v1AddProviderEndpointOptions = (
  options: OptionsLegacyParser<V1AddProviderEndpointData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1AddProviderEndpoint({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1AddProviderEndpointQueryKey(options),
  })
}

export const v1AddProviderEndpointMutation = (
  options?: Partial<OptionsLegacyParser<V1AddProviderEndpointData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1AddProviderEndpointResponse,
    V1AddProviderEndpointError,
    OptionsLegacyParser<V1AddProviderEndpointData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1AddProviderEndpoint({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1ListAllModelsForAllProvidersQueryKey = (
  options?: OptionsLegacyParser
) => [createQueryKey('v1ListAllModelsForAllProviders', options)]

export const v1ListAllModelsForAllProvidersOptions = (
  options?: OptionsLegacyParser
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListAllModelsForAllProviders({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListAllModelsForAllProvidersQueryKey(options),
  })
}

export const v1ListModelsByProviderQueryKey = (
  options: OptionsLegacyParser<V1ListModelsByProviderData>
) => [createQueryKey('v1ListModelsByProvider', options)]

export const v1ListModelsByProviderOptions = (
  options: OptionsLegacyParser<V1ListModelsByProviderData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListModelsByProvider({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListModelsByProviderQueryKey(options),
  })
}

export const v1GetProviderEndpointQueryKey = (
  options: OptionsLegacyParser<V1GetProviderEndpointData>
) => [createQueryKey('v1GetProviderEndpoint', options)]

export const v1GetProviderEndpointOptions = (
  options: OptionsLegacyParser<V1GetProviderEndpointData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetProviderEndpoint({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetProviderEndpointQueryKey(options),
  })
}

export const v1UpdateProviderEndpointMutation = (
  options?: Partial<OptionsLegacyParser<V1UpdateProviderEndpointData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1UpdateProviderEndpointResponse,
    V1UpdateProviderEndpointError,
    OptionsLegacyParser<V1UpdateProviderEndpointData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1UpdateProviderEndpoint({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1DeleteProviderEndpointMutation = (
  options?: Partial<OptionsLegacyParser<V1DeleteProviderEndpointData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1DeleteProviderEndpointResponse,
    V1DeleteProviderEndpointError,
    OptionsLegacyParser<V1DeleteProviderEndpointData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1DeleteProviderEndpoint({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1ConfigureAuthMaterialMutation = (
  options?: Partial<OptionsLegacyParser<V1ConfigureAuthMaterialData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1ConfigureAuthMaterialResponse,
    V1ConfigureAuthMaterialError,
    OptionsLegacyParser<V1ConfigureAuthMaterialData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1ConfigureAuthMaterial({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1ListWorkspacesQueryKey = (options?: OptionsLegacyParser) => [
  createQueryKey('v1ListWorkspaces', options),
]

export const v1ListWorkspacesOptions = (options?: OptionsLegacyParser) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListWorkspaces({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListWorkspacesQueryKey(options),
  })
}

export const v1CreateWorkspaceQueryKey = (
  options: OptionsLegacyParser<V1CreateWorkspaceData>
) => [createQueryKey('v1CreateWorkspace', options)]

export const v1CreateWorkspaceOptions = (
  options: OptionsLegacyParser<V1CreateWorkspaceData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1CreateWorkspace({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1CreateWorkspaceQueryKey(options),
  })
}

export const v1CreateWorkspaceMutation = (
  options?: Partial<OptionsLegacyParser<V1CreateWorkspaceData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1CreateWorkspaceResponse,
    V1CreateWorkspaceError,
    OptionsLegacyParser<V1CreateWorkspaceData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1CreateWorkspace({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1ListActiveWorkspacesQueryKey = (
  options?: OptionsLegacyParser
) => [createQueryKey('v1ListActiveWorkspaces', options)]

export const v1ListActiveWorkspacesOptions = (
  options?: OptionsLegacyParser
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListActiveWorkspaces({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListActiveWorkspacesQueryKey(options),
  })
}

export const v1ActivateWorkspaceQueryKey = (
  options: OptionsLegacyParser<V1ActivateWorkspaceData>
) => [createQueryKey('v1ActivateWorkspace', options)]

export const v1ActivateWorkspaceOptions = (
  options: OptionsLegacyParser<V1ActivateWorkspaceData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ActivateWorkspace({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ActivateWorkspaceQueryKey(options),
  })
}

export const v1ActivateWorkspaceMutation = (
  options?: Partial<OptionsLegacyParser<V1ActivateWorkspaceData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1ActivateWorkspaceResponse,
    V1ActivateWorkspaceError,
    OptionsLegacyParser<V1ActivateWorkspaceData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1ActivateWorkspace({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1UpdateWorkspaceMutation = (
  options?: Partial<OptionsLegacyParser<V1UpdateWorkspaceData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1UpdateWorkspaceResponse,
    V1UpdateWorkspaceError,
    OptionsLegacyParser<V1UpdateWorkspaceData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1UpdateWorkspace({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1DeleteWorkspaceMutation = (
  options?: Partial<OptionsLegacyParser<V1DeleteWorkspaceData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1DeleteWorkspaceResponse,
    V1DeleteWorkspaceError,
    OptionsLegacyParser<V1DeleteWorkspaceData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1DeleteWorkspace({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1ListArchivedWorkspacesQueryKey = (
  options?: OptionsLegacyParser
) => [createQueryKey('v1ListArchivedWorkspaces', options)]

export const v1ListArchivedWorkspacesOptions = (
  options?: OptionsLegacyParser
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListArchivedWorkspaces({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListArchivedWorkspacesQueryKey(options),
  })
}

export const v1RecoverWorkspaceQueryKey = (
  options: OptionsLegacyParser<V1RecoverWorkspaceData>
) => [createQueryKey('v1RecoverWorkspace', options)]

export const v1RecoverWorkspaceOptions = (
  options: OptionsLegacyParser<V1RecoverWorkspaceData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1RecoverWorkspace({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1RecoverWorkspaceQueryKey(options),
  })
}

export const v1RecoverWorkspaceMutation = (
  options?: Partial<OptionsLegacyParser<V1RecoverWorkspaceData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1RecoverWorkspaceResponse,
    V1RecoverWorkspaceError,
    OptionsLegacyParser<V1RecoverWorkspaceData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1RecoverWorkspace({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1HardDeleteWorkspaceMutation = (
  options?: Partial<OptionsLegacyParser<V1HardDeleteWorkspaceData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1HardDeleteWorkspaceResponse,
    V1HardDeleteWorkspaceError,
    OptionsLegacyParser<V1HardDeleteWorkspaceData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1HardDeleteWorkspace({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1GetWorkspaceAlertsQueryKey = (
  options: OptionsLegacyParser<V1GetWorkspaceAlertsData>
) => [createQueryKey('v1GetWorkspaceAlerts', options)]

export const v1GetWorkspaceAlertsOptions = (
  options: OptionsLegacyParser<V1GetWorkspaceAlertsData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetWorkspaceAlerts({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetWorkspaceAlertsQueryKey(options),
  })
}

export const v1GetWorkspaceAlertsSummaryQueryKey = (
  options: OptionsLegacyParser<V1GetWorkspaceAlertsSummaryData>
) => [createQueryKey('v1GetWorkspaceAlertsSummary', options)]

export const v1GetWorkspaceAlertsSummaryOptions = (
  options: OptionsLegacyParser<V1GetWorkspaceAlertsSummaryData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetWorkspaceAlertsSummary({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetWorkspaceAlertsSummaryQueryKey(options),
  })
}

export const v1GetWorkspaceMessagesQueryKey = (
  options: OptionsLegacyParser<V1GetWorkspaceMessagesData>
) => [createQueryKey('v1GetWorkspaceMessages', options)]

export const v1GetWorkspaceMessagesOptions = (
  options: OptionsLegacyParser<V1GetWorkspaceMessagesData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetWorkspaceMessages({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetWorkspaceMessagesQueryKey(options),
  })
}

const createInfiniteParams = <
  K extends Pick<
    QueryKey<OptionsLegacyParser>[0],
    'body' | 'headers' | 'path' | 'query'
  >,
>(
  queryKey: QueryKey<OptionsLegacyParser>,
  page: K
) => {
  const params = queryKey[0]
  if (page.body) {
    params.body = {
      ...(queryKey[0].body as any),
      ...(page.body as any),
    }
  }
  if (page.headers) {
    params.headers = {
      ...queryKey[0].headers,
      ...page.headers,
    }
  }
  if (page.path) {
    params.path = {
      ...queryKey[0].path,
      ...page.path,
    }
  }
  if (page.query) {
    params.query = {
      ...queryKey[0].query,
      ...page.query,
    }
  }
  return params as unknown as typeof page
}

export const v1GetWorkspaceMessagesInfiniteQueryKey = (
  options: OptionsLegacyParser<V1GetWorkspaceMessagesData>
): QueryKey<OptionsLegacyParser<V1GetWorkspaceMessagesData>> => [
  createQueryKey('v1GetWorkspaceMessages', options, true),
]

export const v1GetWorkspaceMessagesInfiniteOptions = (
  options: OptionsLegacyParser<V1GetWorkspaceMessagesData>
) => {
  return infiniteQueryOptions<
    V1GetWorkspaceMessagesResponse,
    V1GetWorkspaceMessagesError,
    InfiniteData<V1GetWorkspaceMessagesResponse>,
    QueryKey<OptionsLegacyParser<V1GetWorkspaceMessagesData>>,
    | number
    | Pick<
        QueryKey<OptionsLegacyParser<V1GetWorkspaceMessagesData>>[0],
        'body' | 'headers' | 'path' | 'query'
      >
  >(
    // @ts-ignore
    {
      queryFn: async ({ pageParam, queryKey, signal }) => {
        // @ts-ignore
        const page: Pick<
          QueryKey<OptionsLegacyParser<V1GetWorkspaceMessagesData>>[0],
          'body' | 'headers' | 'path' | 'query'
        > =
          typeof pageParam === 'object'
            ? pageParam
            : {
                query: {
                  page: pageParam,
                },
              }
        const params = createInfiniteParams(queryKey, page)
        const { data } = await v1GetWorkspaceMessages({
          ...options,
          ...params,
          signal,
          throwOnError: true,
        })
        return data
      },
      queryKey: v1GetWorkspaceMessagesInfiniteQueryKey(options),
    }
  )
}

export const v1GetMessagesByPromptIdQueryKey = (
  options: OptionsLegacyParser<V1GetMessagesByPromptIdData>
) => [createQueryKey('v1GetMessagesByPromptId', options)]

export const v1GetMessagesByPromptIdOptions = (
  options: OptionsLegacyParser<V1GetMessagesByPromptIdData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetMessagesByPromptId({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetMessagesByPromptIdQueryKey(options),
  })
}

export const v1GetWorkspaceCustomInstructionsQueryKey = (
  options: OptionsLegacyParser<V1GetWorkspaceCustomInstructionsData>
) => [createQueryKey('v1GetWorkspaceCustomInstructions', options)]

export const v1GetWorkspaceCustomInstructionsOptions = (
  options: OptionsLegacyParser<V1GetWorkspaceCustomInstructionsData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetWorkspaceCustomInstructions({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetWorkspaceCustomInstructionsQueryKey(options),
  })
}

export const v1SetWorkspaceCustomInstructionsMutation = (
  options?: Partial<OptionsLegacyParser<V1SetWorkspaceCustomInstructionsData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1SetWorkspaceCustomInstructionsResponse,
    V1SetWorkspaceCustomInstructionsError,
    OptionsLegacyParser<V1SetWorkspaceCustomInstructionsData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1SetWorkspaceCustomInstructions({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1DeleteWorkspaceCustomInstructionsMutation = (
  options?: Partial<
    OptionsLegacyParser<V1DeleteWorkspaceCustomInstructionsData>
  >
) => {
  const mutationOptions: UseMutationOptions<
    V1DeleteWorkspaceCustomInstructionsResponse,
    V1DeleteWorkspaceCustomInstructionsError,
    OptionsLegacyParser<V1DeleteWorkspaceCustomInstructionsData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1DeleteWorkspaceCustomInstructions({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1GetWorkspaceMuxesQueryKey = (
  options: OptionsLegacyParser<V1GetWorkspaceMuxesData>
) => [createQueryKey('v1GetWorkspaceMuxes', options)]

export const v1GetWorkspaceMuxesOptions = (
  options: OptionsLegacyParser<V1GetWorkspaceMuxesData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetWorkspaceMuxes({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetWorkspaceMuxesQueryKey(options),
  })
}

export const v1SetWorkspaceMuxesMutation = (
  options?: Partial<OptionsLegacyParser<V1SetWorkspaceMuxesData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1SetWorkspaceMuxesResponse,
    V1SetWorkspaceMuxesError,
    OptionsLegacyParser<V1SetWorkspaceMuxesData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1SetWorkspaceMuxes({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1ListWorkspacesByProviderQueryKey = (
  options: OptionsLegacyParser<V1ListWorkspacesByProviderData>
) => [createQueryKey('v1ListWorkspacesByProvider', options)]

export const v1ListWorkspacesByProviderOptions = (
  options: OptionsLegacyParser<V1ListWorkspacesByProviderData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListWorkspacesByProvider({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListWorkspacesByProviderQueryKey(options),
  })
}

export const v1StreamSseQueryKey = (options?: OptionsLegacyParser) => [
  createQueryKey('v1StreamSse', options),
]

export const v1StreamSseOptions = (options?: OptionsLegacyParser) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1StreamSse({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1StreamSseQueryKey(options),
  })
}

export const v1VersionCheckQueryKey = (options?: OptionsLegacyParser) => [
  createQueryKey('v1VersionCheck', options),
]

export const v1VersionCheckOptions = (options?: OptionsLegacyParser) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1VersionCheck({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1VersionCheckQueryKey(options),
  })
}

export const v1GetWorkspaceTokenUsageQueryKey = (
  options: OptionsLegacyParser<V1GetWorkspaceTokenUsageData>
) => [createQueryKey('v1GetWorkspaceTokenUsage', options)]

export const v1GetWorkspaceTokenUsageOptions = (
  options: OptionsLegacyParser<V1GetWorkspaceTokenUsageData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetWorkspaceTokenUsage({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetWorkspaceTokenUsageQueryKey(options),
  })
}

export const v1ListPersonasQueryKey = (options?: OptionsLegacyParser) => [
  createQueryKey('v1ListPersonas', options),
]

export const v1ListPersonasOptions = (options?: OptionsLegacyParser) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1ListPersonas({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1ListPersonasQueryKey(options),
  })
}

export const v1CreatePersonaQueryKey = (
  options: OptionsLegacyParser<V1CreatePersonaData>
) => [createQueryKey('v1CreatePersona', options)]

export const v1CreatePersonaOptions = (
  options: OptionsLegacyParser<V1CreatePersonaData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1CreatePersona({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1CreatePersonaQueryKey(options),
  })
}

export const v1CreatePersonaMutation = (
  options?: Partial<OptionsLegacyParser<V1CreatePersonaData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1CreatePersonaResponse,
    V1CreatePersonaError,
    OptionsLegacyParser<V1CreatePersonaData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1CreatePersona({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1GetPersonaQueryKey = (
  options: OptionsLegacyParser<V1GetPersonaData>
) => [createQueryKey('v1GetPersona', options)]

export const v1GetPersonaOptions = (
  options: OptionsLegacyParser<V1GetPersonaData>
) => {
  return queryOptions({
    queryFn: async ({ queryKey, signal }) => {
      const { data } = await v1GetPersona({
        ...options,
        ...queryKey[0],
        signal,
        throwOnError: true,
      })
      return data
    },
    queryKey: v1GetPersonaQueryKey(options),
  })
}

export const v1UpdatePersonaMutation = (
  options?: Partial<OptionsLegacyParser<V1UpdatePersonaData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1UpdatePersonaResponse,
    V1UpdatePersonaError,
    OptionsLegacyParser<V1UpdatePersonaData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1UpdatePersona({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

export const v1DeletePersonaMutation = (
  options?: Partial<OptionsLegacyParser<V1DeletePersonaData>>
) => {
  const mutationOptions: UseMutationOptions<
    V1DeletePersonaResponse,
    V1DeletePersonaError,
    OptionsLegacyParser<V1DeletePersonaData>
  > = {
    mutationFn: async (localOptions) => {
      const { data } = await v1DeletePersona({
        ...options,
        ...localOptions,
        throwOnError: true,
      })
      return data
    },
  }
  return mutationOptions
}

stacklok / codegate-ui / 13786985073

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous