12954373020

Committed 24 Jan 2025 05:19PM UTC coverage: 68.382% (-3.1%) from 71.466%

Build # 12954373020

Build Type

Pull #203

github

Committed by

web-flow

Commit Message

Merge bfdac3c3e into 9129a5b98

Pull Request Pull Request #203: doc: removed help md files linking directly to documentation

Run Details

345 of 604 branches covered (57.12%)

Branch coverage included in aggregate %.

28 of 86 new or added lines in 4 files covered. (32.56%)

3 existing lines in 1 file now uncovered.

758 of 1009 relevant lines covered (75.12%)

60.31 hits per line

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

57.61

/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,
  v1GetProviderEndpoint,
  v1UpdateProviderEndpoint,
  v1DeleteProviderEndpoint,
  v1ListModelsByProvider,
  v1ListAllModelsForAllProviders,
  v1ListWorkspaces,
  v1CreateWorkspace,
  v1ListActiveWorkspaces,
  v1ActivateWorkspace,
  v1DeleteWorkspace,
  v1ListArchivedWorkspaces,
  v1RecoverWorkspace,
  v1HardDeleteWorkspace,
  v1GetWorkspaceAlerts,
  v1GetWorkspaceMessages,
  v1GetWorkspaceCustomInstructions,
  v1SetWorkspaceCustomInstructions,
  v1DeleteWorkspaceCustomInstructions,
  v1GetWorkspaceMuxes,
  v1SetWorkspaceMuxes,
  v1StreamSse,
  v1VersionCheck,
} from "../sdk.gen";
import type {
  V1ListProviderEndpointsData,
  V1AddProviderEndpointData,
  V1AddProviderEndpointError,
  V1AddProviderEndpointResponse,
  V1GetProviderEndpointData,
  V1UpdateProviderEndpointData,
  V1UpdateProviderEndpointError,
  V1UpdateProviderEndpointResponse,
  V1DeleteProviderEndpointData,
  V1DeleteProviderEndpointError,
  V1DeleteProviderEndpointResponse,
  V1ListModelsByProviderData,
  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,
} 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 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 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 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 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),
  });
};

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

stacklok / codegate-ui / 12954373020

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