13031229229

Committed 29 Jan 2025 12:23PM UTC coverage: 68.885% (+1.8%) from 67.071%

Build # 13031229229

Build Type

Pull #217

github

Committed by

web-flow

Commit Message

Merge 2389df263 into 25a531eba

Pull Request Pull Request #217: feat(muxing): add workspace model overrides

Run Details

378 of 660 branches covered (57.27%)

Branch coverage included in aggregate %.

30 of 40 new or added lines in 7 files covered. (75.0%)

70 existing lines in 3 files now uncovered.

833 of 1098 relevant lines covered (75.87%)

63.69 hits per line

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

61.05

/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 } from "@tanstack/react-query";
import {
  client,
  healthCheckHealthGet,
  v1ListProviderEndpoints,
  v1AddProviderEndpoint,
  v1ListAllModelsForAllProviders,
  v1ListModelsByProvider,
  v1GetProviderEndpoint,
  v1UpdateProviderEndpoint,
  v1DeleteProviderEndpoint,
  v1ListWorkspaces,
  v1CreateWorkspace,
  v1ListActiveWorkspaces,
  v1ActivateWorkspace,
  v1DeleteWorkspace,
  v1ListArchivedWorkspaces,
  v1RecoverWorkspace,
  v1HardDeleteWorkspace,
  v1GetWorkspaceAlerts,
  v1GetWorkspaceMessages,
  v1GetWorkspaceCustomInstructions,
  v1SetWorkspaceCustomInstructions,
  v1DeleteWorkspaceCustomInstructions,
  v1GetWorkspaceMuxes,
  v1SetWorkspaceMuxes,
  v1StreamSse,
  v1VersionCheck,
  v1GetWorkspaceTokenUsage,
} from "../sdk.gen";
import type {
  V1ListProviderEndpointsData,
  V1AddProviderEndpointData,
  V1AddProviderEndpointError,
  V1AddProviderEndpointResponse,
  V1ListModelsByProviderData,
  V1GetProviderEndpointData,
  V1UpdateProviderEndpointData,
  V1UpdateProviderEndpointError,
  V1UpdateProviderEndpointResponse,
  V1DeleteProviderEndpointData,
  V1DeleteProviderEndpointError,
  V1DeleteProviderEndpointResponse,
  V1CreateWorkspaceData,
  V1CreateWorkspaceError,
  V1CreateWorkspaceResponse,
  V1ActivateWorkspaceData,
  V1ActivateWorkspaceError,
  V1ActivateWorkspaceResponse,
  V1DeleteWorkspaceData,
  V1DeleteWorkspaceError,
  V1DeleteWorkspaceResponse,
  V1RecoverWorkspaceData,
  V1RecoverWorkspaceError,
  V1RecoverWorkspaceResponse,
  V1HardDeleteWorkspaceData,
  V1HardDeleteWorkspaceError,
  V1HardDeleteWorkspaceResponse,
  V1GetWorkspaceAlertsData,
  V1GetWorkspaceMessagesData,
  V1GetWorkspaceCustomInstructionsData,
  V1SetWorkspaceCustomInstructionsData,
  V1SetWorkspaceCustomInstructionsError,
  V1SetWorkspaceCustomInstructionsResponse,
  V1DeleteWorkspaceCustomInstructionsData,
  V1DeleteWorkspaceCustomInstructionsError,
  V1DeleteWorkspaceCustomInstructionsResponse,
  V1GetWorkspaceMuxesData,
  V1SetWorkspaceMuxesData,
  V1SetWorkspaceMuxesError,
  V1SetWorkspaceMuxesResponse,
  V1GetWorkspaceTokenUsageData,
} 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 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 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 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),
  });
};

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 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),
  });
};

1	// This file is auto-generated by @hey-api/openapi-ts
2
3	import type { OptionsLegacyParser } from "@hey-api/client-fetch";
4	import { queryOptions, type UseMutationOptions } from "@tanstack/react-query";
5	import {
6	client,
7	healthCheckHealthGet,
8	v1ListProviderEndpoints,
9	v1AddProviderEndpoint,
10	v1ListAllModelsForAllProviders,
11	v1ListModelsByProvider,
12	v1GetProviderEndpoint,
13	v1UpdateProviderEndpoint,
14	v1DeleteProviderEndpoint,
15	v1ListWorkspaces,
16	v1CreateWorkspace,
17	v1ListActiveWorkspaces,
18	v1ActivateWorkspace,
19	v1DeleteWorkspace,
20	v1ListArchivedWorkspaces,
21	v1RecoverWorkspace,
22	v1HardDeleteWorkspace,
23	v1GetWorkspaceAlerts,
24	v1GetWorkspaceMessages,
25	v1GetWorkspaceCustomInstructions,
26	v1SetWorkspaceCustomInstructions,
27	v1DeleteWorkspaceCustomInstructions,
28	v1GetWorkspaceMuxes,
29	v1SetWorkspaceMuxes,
30	v1StreamSse,
31	v1VersionCheck,
32	v1GetWorkspaceTokenUsage,
33	} from "../sdk.gen";
34	import type {
35	V1ListProviderEndpointsData,
36	V1AddProviderEndpointData,
37	V1AddProviderEndpointError,
38	V1AddProviderEndpointResponse,
39	V1ListModelsByProviderData,
40	V1GetProviderEndpointData,
41	V1UpdateProviderEndpointData,
42	V1UpdateProviderEndpointError,
43	V1UpdateProviderEndpointResponse,
44	V1DeleteProviderEndpointData,
45	V1DeleteProviderEndpointError,
46	V1DeleteProviderEndpointResponse,
47	V1CreateWorkspaceData,
48	V1CreateWorkspaceError,
49	V1CreateWorkspaceResponse,
50	V1ActivateWorkspaceData,
51	V1ActivateWorkspaceError,
52	V1ActivateWorkspaceResponse,
53	V1DeleteWorkspaceData,
54	V1DeleteWorkspaceError,
55	V1DeleteWorkspaceResponse,
56	V1RecoverWorkspaceData,
57	V1RecoverWorkspaceError,
58	V1RecoverWorkspaceResponse,
59	V1HardDeleteWorkspaceData,
60	V1HardDeleteWorkspaceError,
61	V1HardDeleteWorkspaceResponse,
62	V1GetWorkspaceAlertsData,
63	V1GetWorkspaceMessagesData,
64	V1GetWorkspaceCustomInstructionsData,
65	V1SetWorkspaceCustomInstructionsData,
66	V1SetWorkspaceCustomInstructionsError,
67	V1SetWorkspaceCustomInstructionsResponse,
68	V1DeleteWorkspaceCustomInstructionsData,
69	V1DeleteWorkspaceCustomInstructionsError,
70	V1DeleteWorkspaceCustomInstructionsResponse,
71	V1GetWorkspaceMuxesData,
72	V1SetWorkspaceMuxesData,
73	V1SetWorkspaceMuxesError,
74	V1SetWorkspaceMuxesResponse,
75	V1GetWorkspaceTokenUsageData,
76	} from "../types.gen";
77
78	type QueryKey<TOptions extends OptionsLegacyParser> = [
79	Pick<TOptions, "baseUrl" \| "body" \| "headers" \| "path" \| "query"> & {
80	_id: string;
81	_infinite?: boolean;
82	},
83	];
84
85	const createQueryKey = <TOptions extends OptionsLegacyParser>(	13✔
86	id: string,
87	options?: TOptions,
88	infinite?: boolean,
89	): QueryKey<TOptions>[0] => {
90	const params: QueryKey<TOptions>[0] = {	817✔
91	_id: id,
92	baseUrl: (options?.client ?? client).getConfig().baseUrl,	1,634✔
93	} as QueryKey<TOptions>[0];
94	if (infinite) {	817!
UNCOV 95	params._infinite = infinite;	×
96	}
97	if (options?.body) {	817!
UNCOV 98	params.body = options.body;	×
99	}
100	if (options?.headers) {	817!
UNCOV 101	params.headers = options.headers;	×
102	}
103	if (options?.path) {	817✔
104	params.path = options.path;	342✔
105	}
106	if (options?.query) {	817!
UNCOV 107	params.query = options.query;	×
108	}
109	return params;	817✔
110	};
111
112	export const healthCheckHealthGetQueryKey = (options?: OptionsLegacyParser) => [	13✔
113	createQueryKey("healthCheckHealthGet", options),
114	];
115
116	export const healthCheckHealthGetOptions = (options?: OptionsLegacyParser) => {	13✔
UNCOV 117	return queryOptions({	×
118	queryFn: async ({ queryKey, signal }) => {
UNCOV 119	const { data } = await healthCheckHealthGet({	×
120	...options,
121	...queryKey[0],
122	signal,
123	throwOnError: true,
124	});
UNCOV 125	return data;	×
126	},
127	queryKey: healthCheckHealthGetQueryKey(options),
128	});
129	};
130
131	export const v1ListProviderEndpointsQueryKey = (	13✔
132	options?: OptionsLegacyParser<V1ListProviderEndpointsData>,
UNCOV 133	) => [createQueryKey("v1ListProviderEndpoints", options)];	×
134
135	export const v1ListProviderEndpointsOptions = (	13✔
136	options?: OptionsLegacyParser<V1ListProviderEndpointsData>,
137	) => {
UNCOV 138	return queryOptions({	×
139	queryFn: async ({ queryKey, signal }) => {
UNCOV 140	const { data } = await v1ListProviderEndpoints({	×
141	...options,
142	...queryKey[0],
143	signal,
144	throwOnError: true,
145	});
UNCOV 146	return data;	×
147	},
148	queryKey: v1ListProviderEndpointsQueryKey(options),
149	});
150	};
151
152	export const v1AddProviderEndpointQueryKey = (	13✔
153	options: OptionsLegacyParser<V1AddProviderEndpointData>,
UNCOV 154	) => [createQueryKey("v1AddProviderEndpoint", options)];	×
155
156	export const v1AddProviderEndpointOptions = (	13✔
157	options: OptionsLegacyParser<V1AddProviderEndpointData>,
158	) => {
UNCOV 159	return queryOptions({	×
160	queryFn: async ({ queryKey, signal }) => {
UNCOV 161	const { data } = await v1AddProviderEndpoint({	×
162	...options,
163	...queryKey[0],
164	signal,
165	throwOnError: true,
166	});
UNCOV 167	return data;	×
168	},
169	queryKey: v1AddProviderEndpointQueryKey(options),
170	});
171	};
172
173	export const v1AddProviderEndpointMutation = (	13✔
174	options?: Partial<OptionsLegacyParser<V1AddProviderEndpointData>>,
175	) => {
176	const mutationOptions: UseMutationOptions<
177	V1AddProviderEndpointResponse,
178	V1AddProviderEndpointError,
179	OptionsLegacyParser<V1AddProviderEndpointData>
UNCOV 180	> = {	×
181	mutationFn: async (localOptions) => {
UNCOV 182	const { data } = await v1AddProviderEndpoint({	×
183	...options,
184	...localOptions,
185	throwOnError: true,
186	});
UNCOV 187	return data;	×
188	},
189	};
UNCOV 190	return mutationOptions;	×
191	};
192
193	export const v1ListAllModelsForAllProvidersQueryKey = (	13✔
194	options?: OptionsLegacyParser,
195	) => [createQueryKey("v1ListAllModelsForAllProviders", options)];	14✔
196
197	export const v1ListAllModelsForAllProvidersOptions = (	13✔
198	options?: OptionsLegacyParser,
199	) => {
200	return queryOptions({	14✔
201	queryFn: async ({ queryKey, signal }) => {
NEW 202	const { data } = await v1ListAllModelsForAllProviders({	×
203	...options,
204	...queryKey[0],
205	signal,
206	throwOnError: true,
207	});
NEW 208	return data;	×
209	},
210	queryKey: v1ListAllModelsForAllProvidersQueryKey(options),
211	});
212	};
213
214	export const v1ListModelsByProviderQueryKey = (	13✔
215	options: OptionsLegacyParser<V1ListModelsByProviderData>,
NEW 216	) => [createQueryKey("v1ListModelsByProvider", options)];	×
217
218	export const v1ListModelsByProviderOptions = (	13✔
219	options: OptionsLegacyParser<V1ListModelsByProviderData>,
220	) => {
NEW 221	return queryOptions({	×
222	queryFn: async ({ queryKey, signal }) => {
NEW 223	const { data } = await v1ListModelsByProvider({	×
224	...options,
225	...queryKey[0],
226	signal,
227	throwOnError: true,
228	});
NEW 229	return data;	×
230	},
231	queryKey: v1ListModelsByProviderQueryKey(options),
232	});
233	};
234
235	export const v1GetProviderEndpointQueryKey = (	13✔
236	options: OptionsLegacyParser<V1GetProviderEndpointData>,
237	) => [createQueryKey("v1GetProviderEndpoint", options)];	×
238
239	export const v1GetProviderEndpointOptions = (	13✔
240	options: OptionsLegacyParser<V1GetProviderEndpointData>,
241	) => {
UNCOV 242	return queryOptions({	×
243	queryFn: async ({ queryKey, signal }) => {
UNCOV 244	const { data } = await v1GetProviderEndpoint({	×
245	...options,
246	...queryKey[0],
247	signal,
248	throwOnError: true,
249	});
UNCOV 250	return data;	×
251	},
252	queryKey: v1GetProviderEndpointQueryKey(options),
253	});
254	};
255
256	export const v1UpdateProviderEndpointMutation = (	13✔
257	options?: Partial<OptionsLegacyParser<V1UpdateProviderEndpointData>>,
258	) => {
259	const mutationOptions: UseMutationOptions<
260	V1UpdateProviderEndpointResponse,
261	V1UpdateProviderEndpointError,
262	OptionsLegacyParser<V1UpdateProviderEndpointData>
UNCOV 263	> = {	×
264	mutationFn: async (localOptions) => {
UNCOV 265	const { data } = await v1UpdateProviderEndpoint({	×
266	...options,
267	...localOptions,
268	throwOnError: true,
269	});
UNCOV 270	return data;	×
271	},
272	};
UNCOV 273	return mutationOptions;	×
274	};
275
276	export const v1DeleteProviderEndpointMutation = (	13✔
277	options?: Partial<OptionsLegacyParser<V1DeleteProviderEndpointData>>,
278	) => {
279	const mutationOptions: UseMutationOptions<
280	V1DeleteProviderEndpointResponse,
281	V1DeleteProviderEndpointError,
282	OptionsLegacyParser<V1DeleteProviderEndpointData>
UNCOV 283	> = {	×
284	mutationFn: async (localOptions) => {
UNCOV 285	const { data } = await v1DeleteProviderEndpoint({	×
286	...options,
287	...localOptions,
288	throwOnError: true,
289	});
UNCOV 290	return data;	×
291	},
292	};
UNCOV 293	return mutationOptions;	×
294	};
295
296	export const v1ListWorkspacesQueryKey = (options?: OptionsLegacyParser) => [	35✔
297	createQueryKey("v1ListWorkspaces", options),
298	];
299
300	export const v1ListWorkspacesOptions = (options?: OptionsLegacyParser) => {	13✔
301	return queryOptions({	27✔
302	queryFn: async ({ queryKey, signal }) => {
303	const { data } = await v1ListWorkspaces({	8✔
304	...options,
305	...queryKey[0],
306	signal,
307	throwOnError: true,
308	});
309	return data;	4✔
310	},
311	queryKey: v1ListWorkspacesQueryKey(options),
312	});
313	};
314
315	export const v1CreateWorkspaceQueryKey = (	13✔
316	options: OptionsLegacyParser<V1CreateWorkspaceData>,
317	) => [createQueryKey("v1CreateWorkspace", options)];	×
318
319	export const v1CreateWorkspaceOptions = (	13✔
320	options: OptionsLegacyParser<V1CreateWorkspaceData>,
321	) => {
UNCOV 322	return queryOptions({	×
323	queryFn: async ({ queryKey, signal }) => {
UNCOV 324	const { data } = await v1CreateWorkspace({	×
325	...options,
326	...queryKey[0],
327	signal,
328	throwOnError: true,
329	});
UNCOV 330	return data;	×
331	},
332	queryKey: v1CreateWorkspaceQueryKey(options),
333	});
334	};
335
336	export const v1CreateWorkspaceMutation = (	13✔
337	options?: Partial<OptionsLegacyParser<V1CreateWorkspaceData>>,
338	) => {
339	const mutationOptions: UseMutationOptions<
340	V1CreateWorkspaceResponse,
341	V1CreateWorkspaceError,
342	OptionsLegacyParser<V1CreateWorkspaceData>
343	> = {	58✔
344	mutationFn: async (localOptions) => {
345	const { data } = await v1CreateWorkspace({	4✔
346	...options,
347	...localOptions,
348	throwOnError: true,
349	});
350	return data;	4✔
351	},
352	};
353	return mutationOptions;	58✔
354	};
355
356	export const v1ListActiveWorkspacesQueryKey = (	13✔
357	options?: OptionsLegacyParser,
358	) => [createQueryKey("v1ListActiveWorkspaces", options)];	393✔
359
360	export const v1ListActiveWorkspacesOptions = (	13✔
361	options?: OptionsLegacyParser,
362	) => {
363	return queryOptions({	393✔
364	queryFn: async ({ queryKey, signal }) => {
365	const { data } = await v1ListActiveWorkspaces({	43✔
366	...options,
367	...queryKey[0],
368	signal,
369	throwOnError: true,
370	});
371	return data;	35✔
372	},
373	queryKey: v1ListActiveWorkspacesQueryKey(options),
374	});
375	};
376
377	export const v1ActivateWorkspaceQueryKey = (	13✔
378	options: OptionsLegacyParser<V1ActivateWorkspaceData>,
UNCOV 379	) => [createQueryKey("v1ActivateWorkspace", options)];	×
380
381	export const v1ActivateWorkspaceOptions = (	13✔
382	options: OptionsLegacyParser<V1ActivateWorkspaceData>,
383	) => {
UNCOV 384	return queryOptions({	×
385	queryFn: async ({ queryKey, signal }) => {
UNCOV 386	const { data } = await v1ActivateWorkspace({	×
387	...options,
388	...queryKey[0],
389	signal,
390	throwOnError: true,
391	});
UNCOV 392	return data;	×
393	},
394	queryKey: v1ActivateWorkspaceQueryKey(options),
395	});
396	};
397
398	export const v1ActivateWorkspaceMutation = (	13✔
399	options?: Partial<OptionsLegacyParser<V1ActivateWorkspaceData>>,
400	) => {
401	const mutationOptions: UseMutationOptions<
402	V1ActivateWorkspaceResponse,
403	V1ActivateWorkspaceError,
404	OptionsLegacyParser<V1ActivateWorkspaceData>
405	> = {	50✔
406	mutationFn: async (localOptions) => {
407	const { data } = await v1ActivateWorkspace({	2✔
408	...options,
409	...localOptions,
410	throwOnError: true,
411	});
412	return data;	2✔
413	},
414	};
415	return mutationOptions;	50✔
416	};
417
418	export const v1DeleteWorkspaceMutation = (	13✔
419	options?: Partial<OptionsLegacyParser<V1DeleteWorkspaceData>>,
420	) => {
421	const mutationOptions: UseMutationOptions<
422	V1DeleteWorkspaceResponse,
423	V1DeleteWorkspaceError,
424	OptionsLegacyParser<V1DeleteWorkspaceData>
425	> = {	58✔
426	mutationFn: async (localOptions) => {
427	const { data } = await v1DeleteWorkspace({	2✔
428	...options,
429	...localOptions,
430	throwOnError: true,
431	});
432	return data;	2✔
433	},
434	};
435	return mutationOptions;	58✔
436	};
437
438	export const v1ListArchivedWorkspacesQueryKey = (	13✔
439	options?: OptionsLegacyParser,
440	) => [createQueryKey("v1ListArchivedWorkspaces", options)];	33✔
441
442	export const v1ListArchivedWorkspacesOptions = (	13✔
443	options?: OptionsLegacyParser,
444	) => {
445	return queryOptions({	14✔
446	queryFn: async ({ queryKey, signal }) => {
447	const { data } = await v1ListArchivedWorkspaces({	11✔
448	...options,
449	...queryKey[0],
450	signal,
451	throwOnError: true,
452	});
453	return data;	5✔
454	},
455	queryKey: v1ListArchivedWorkspacesQueryKey(options),
456	});
457	};
458
459	export const v1RecoverWorkspaceQueryKey = (	13✔
460	options: OptionsLegacyParser<V1RecoverWorkspaceData>,
UNCOV 461	) => [createQueryKey("v1RecoverWorkspace", options)];	×
462
463	export const v1RecoverWorkspaceOptions = (	13✔
464	options: OptionsLegacyParser<V1RecoverWorkspaceData>,
465	) => {
UNCOV 466	return queryOptions({	×
467	queryFn: async ({ queryKey, signal }) => {
UNCOV 468	const { data } = await v1RecoverWorkspace({	×
469	...options,
470	...queryKey[0],
471	signal,
472	throwOnError: true,
473	});
UNCOV 474	return data;	×
475	},
476	queryKey: v1RecoverWorkspaceQueryKey(options),
477	});
478	};
479
480	export const v1RecoverWorkspaceMutation = (	13✔
481	options?: Partial<OptionsLegacyParser<V1RecoverWorkspaceData>>,
482	) => {
483	const mutationOptions: UseMutationOptions<
484	V1RecoverWorkspaceResponse,
485	V1RecoverWorkspaceError,
486	OptionsLegacyParser<V1RecoverWorkspaceData>
487	> = {	48✔
488	mutationFn: async (localOptions) => {
489	const { data } = await v1RecoverWorkspace({	2✔
490	...options,
491	...localOptions,
492	throwOnError: true,
493	});
494	return data;	2✔
495	},
496	};
497	return mutationOptions;	48✔
498	};
499
500	export const v1HardDeleteWorkspaceMutation = (	13✔
501	options?: Partial<OptionsLegacyParser<V1HardDeleteWorkspaceData>>,
502	) => {
503	const mutationOptions: UseMutationOptions<
504	V1HardDeleteWorkspaceResponse,
505	V1HardDeleteWorkspaceError,
506	OptionsLegacyParser<V1HardDeleteWorkspaceData>
507	> = {	48✔
508	mutationFn: async (localOptions) => {
509	const { data } = await v1HardDeleteWorkspace({	2✔
510	...options,
511	...localOptions,
512	throwOnError: true,
513	});
514	return data;	2✔
515	},
516	};
517	return mutationOptions;	48✔
518	};
519
520	export const v1GetWorkspaceAlertsQueryKey = (	13✔
521	options: OptionsLegacyParser<V1GetWorkspaceAlertsData>,
522	) => [createQueryKey("v1GetWorkspaceAlerts", options)];	279✔
523
524	export const v1GetWorkspaceAlertsOptions = (	13✔
525	options: OptionsLegacyParser<V1GetWorkspaceAlertsData>,
526	) => {
UNCOV 527	return queryOptions({	×
528	queryFn: async ({ queryKey, signal }) => {
UNCOV 529	const { data } = await v1GetWorkspaceAlerts({	×
530	...options,
531	...queryKey[0],
532	signal,
533	throwOnError: true,
534	});
UNCOV 535	return data;	×
536	},
537	queryKey: v1GetWorkspaceAlertsQueryKey(options),
538	});
539	};
540
541	export const v1GetWorkspaceMessagesQueryKey = (	13✔
542	options: OptionsLegacyParser<V1GetWorkspaceMessagesData>,
543	) => [createQueryKey("v1GetWorkspaceMessages", options)];	6✔
544
545	export const v1GetWorkspaceMessagesOptions = (	13✔
546	options: OptionsLegacyParser<V1GetWorkspaceMessagesData>,
547	) => {
548	return queryOptions({	6✔
549	queryFn: async ({ queryKey, signal }) => {
550	const { data } = await v1GetWorkspaceMessages({	4✔
551	...options,
552	...queryKey[0],
553	signal,
554	throwOnError: true,
555	});
556	return data;	4✔
557	},
558	queryKey: v1GetWorkspaceMessagesQueryKey(options),
559	});
560	};
561
562	export const v1GetWorkspaceCustomInstructionsQueryKey = (	13✔
563	options: OptionsLegacyParser<V1GetWorkspaceCustomInstructionsData>,
564	) => [createQueryKey("v1GetWorkspaceCustomInstructions", options)];	57✔
565
566	export const v1GetWorkspaceCustomInstructionsOptions = (	13✔
567	options: OptionsLegacyParser<V1GetWorkspaceCustomInstructionsData>,
568	) => {
569	return queryOptions({	40✔
570	queryFn: async ({ queryKey, signal }) => {
571	const { data } = await v1GetWorkspaceCustomInstructions({	8✔
572	...options,
573	...queryKey[0],
574	signal,
575	throwOnError: true,
576	});
577	return data;	5✔
578	},
579	queryKey: v1GetWorkspaceCustomInstructionsQueryKey(options),
580	});
581	};
582
583	export const v1SetWorkspaceCustomInstructionsMutation = (	13✔
584	options?: Partial<OptionsLegacyParser<V1SetWorkspaceCustomInstructionsData>>,
585	) => {
586	const mutationOptions: UseMutationOptions<
587	V1SetWorkspaceCustomInstructionsResponse,
588	V1SetWorkspaceCustomInstructionsError,
589	OptionsLegacyParser<V1SetWorkspaceCustomInstructionsData>
590	> = {	40✔
591	mutationFn: async (localOptions) => {
592	const { data } = await v1SetWorkspaceCustomInstructions({	1✔
593	...options,
594	...localOptions,
595	throwOnError: true,
596	});
597	return data;	1✔
598	},
599	};
600	return mutationOptions;	40✔
601	};
602
603	export const v1DeleteWorkspaceCustomInstructionsMutation = (	13✔
604	options?: Partial<
605	OptionsLegacyParser<V1DeleteWorkspaceCustomInstructionsData>
606	>,
607	) => {
608	const mutationOptions: UseMutationOptions<
609	V1DeleteWorkspaceCustomInstructionsResponse,
610	V1DeleteWorkspaceCustomInstructionsError,
611	OptionsLegacyParser<V1DeleteWorkspaceCustomInstructionsData>
UNCOV 612	> = {	×
613	mutationFn: async (localOptions) => {
UNCOV 614	const { data } = await v1DeleteWorkspaceCustomInstructions({	×
615	...options,
616	...localOptions,
617	throwOnError: true,
618	});
UNCOV 619	return data;	×
620	},
621	};
UNCOV 622	return mutationOptions;	×
623	};
624
625	export const v1GetWorkspaceMuxesQueryKey = (	13✔
626	options: OptionsLegacyParser<V1GetWorkspaceMuxesData>,
UNCOV 627	) => [createQueryKey("v1GetWorkspaceMuxes", options)];	×
628
629	export const v1GetWorkspaceMuxesOptions = (	13✔
630	options: OptionsLegacyParser<V1GetWorkspaceMuxesData>,
631	) => {
UNCOV 632	return queryOptions({	×
633	queryFn: async ({ queryKey, signal }) => {
UNCOV 634	const { data } = await v1GetWorkspaceMuxes({	×
635	...options,
636	...queryKey[0],
637	signal,
638	throwOnError: true,
639	});
UNCOV 640	return data;	×
641	},
642	queryKey: v1GetWorkspaceMuxesQueryKey(options),
643	});
644	};
645
646	export const v1SetWorkspaceMuxesMutation = (	13✔
647	options?: Partial<OptionsLegacyParser<V1SetWorkspaceMuxesData>>,
648	) => {
649	const mutationOptions: UseMutationOptions<
650	V1SetWorkspaceMuxesResponse,
651	V1SetWorkspaceMuxesError,
652	OptionsLegacyParser<V1SetWorkspaceMuxesData>
653	> = {	14✔
654	mutationFn: async (localOptions) => {
655	const { data } = await v1SetWorkspaceMuxes({	1✔
656	...options,
657	...localOptions,
658	throwOnError: true,
659	});
660	return data;	1✔
661	},
662	};
663	return mutationOptions;	14✔
664	};
665
666	export const v1StreamSseQueryKey = (options?: OptionsLegacyParser) => [	13✔
667	createQueryKey("v1StreamSse", options),
668	];
669
670	export const v1StreamSseOptions = (options?: OptionsLegacyParser) => {	13✔
UNCOV 671	return queryOptions({	×
672	queryFn: async ({ queryKey, signal }) => {
UNCOV 673	const { data } = await v1StreamSse({	×
674	...options,
675	...queryKey[0],
676	signal,
677	throwOnError: true,
678	});
679	return data;	×
680	},
681	queryKey: v1StreamSseQueryKey(options),
682	});
683	};
684
685	export const v1VersionCheckQueryKey = (options?: OptionsLegacyParser) => [	13✔
686	createQueryKey("v1VersionCheck", options),
687	];
688
689	export const v1VersionCheckOptions = (options?: OptionsLegacyParser) => {	13✔
UNCOV 690	return queryOptions({	×
691	queryFn: async ({ queryKey, signal }) => {
UNCOV 692	const { data } = await v1VersionCheck({	×
693	...options,
694	...queryKey[0],
695	signal,
696	throwOnError: true,
697	});
UNCOV 698	return data;	×
699	},
700	queryKey: v1VersionCheckQueryKey(options),
701	});
702	};
703
704	export const v1GetWorkspaceTokenUsageQueryKey = (	13✔
705	options: OptionsLegacyParser<V1GetWorkspaceTokenUsageData>,
UNCOV 706	) => [createQueryKey("v1GetWorkspaceTokenUsage", options)];	×
707
708	export const v1GetWorkspaceTokenUsageOptions = (	13✔
709	options: OptionsLegacyParser<V1GetWorkspaceTokenUsageData>,
710	) => {
UNCOV 711	return queryOptions({	×
712	queryFn: async ({ queryKey, signal }) => {
UNCOV 713	const { data } = await v1GetWorkspaceTokenUsage({	×
714	...options,
715	...queryKey[0],
716	signal,
717	throwOnError: true,
718	});
UNCOV 719	return data;	×
720	},
721	queryKey: v1GetWorkspaceTokenUsageQueryKey(options),
722	});
723	};

stacklok / codegate-ui / 13031229229

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