@omnara/sdk 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +37 -0
- package/dist/auth-CnOxLjlL.d.ts +6 -0
- package/dist/browser.d.ts +32 -0
- package/dist/browser.js +121 -0
- package/dist/browser.js.map +1 -0
- package/dist/chunk-CT4AUW4R.js +3657 -0
- package/dist/chunk-CT4AUW4R.js.map +1 -0
- package/dist/chunk-DGGYBF7D.js +3642 -0
- package/dist/chunk-DGGYBF7D.js.map +1 -0
- package/dist/chunk-PZ5AY32C.js +10 -0
- package/dist/chunk-PZ5AY32C.js.map +1 -0
- package/dist/chunk-TMPF6DRL.js +35 -0
- package/dist/chunk-TMPF6DRL.js.map +1 -0
- package/dist/index.d.ts +86 -0
- package/dist/index.js +254 -0
- package/dist/index.js.map +1 -0
- package/dist/sdk.gen-j-xlf6lr.d.ts +12953 -0
- package/dist/tanstack.d.ts +2786 -0
- package/dist/tanstack.js +2954 -0
- package/dist/tanstack.js.map +1 -0
- package/dist/zod.d.ts +12526 -0
- package/dist/zod.js +1428 -0
- package/dist/zod.js.map +1 -0
- package/package.json +64 -0
package/dist/tanstack.js
ADDED
|
@@ -0,0 +1,2954 @@
|
|
|
1
|
+
import {
|
|
2
|
+
acceptInvitation,
|
|
3
|
+
archiveAgent,
|
|
4
|
+
bootstrapDaemon,
|
|
5
|
+
cancelAgent,
|
|
6
|
+
cancelQueuedBacklogInput,
|
|
7
|
+
client,
|
|
8
|
+
connectByoMachine,
|
|
9
|
+
createAgent,
|
|
10
|
+
createAgentConfig,
|
|
11
|
+
createAgentInput,
|
|
12
|
+
createAgentProfile,
|
|
13
|
+
createByoMachineDaemonToken,
|
|
14
|
+
createConfiguredModel,
|
|
15
|
+
createCronTrigger,
|
|
16
|
+
createIntegrationOAuthSetup,
|
|
17
|
+
createMachine,
|
|
18
|
+
createMachinePool,
|
|
19
|
+
createModelProviderConfig,
|
|
20
|
+
createOrgApiKey,
|
|
21
|
+
createOrgInvitation,
|
|
22
|
+
createOrganization,
|
|
23
|
+
createPersonalAccessToken,
|
|
24
|
+
createProject,
|
|
25
|
+
createProjectMachineGrant,
|
|
26
|
+
createProjectMachinePoolGrant,
|
|
27
|
+
createProjectModelGrant,
|
|
28
|
+
createSecret,
|
|
29
|
+
createSecretGrant,
|
|
30
|
+
createSecretVersion,
|
|
31
|
+
createSkill,
|
|
32
|
+
createSkillGrant,
|
|
33
|
+
createSlackSetup,
|
|
34
|
+
declineInvitation,
|
|
35
|
+
deleteAgentProfile,
|
|
36
|
+
deleteConfiguredModel,
|
|
37
|
+
deleteCronTrigger,
|
|
38
|
+
deleteCurrentUser,
|
|
39
|
+
deleteIntegrationInstall,
|
|
40
|
+
deleteMachine,
|
|
41
|
+
deleteMachinePool,
|
|
42
|
+
deleteModelProviderConfig,
|
|
43
|
+
deleteOrgInvitation,
|
|
44
|
+
deleteOrganization,
|
|
45
|
+
deleteProject,
|
|
46
|
+
deleteProjectMachineGrant,
|
|
47
|
+
deleteProjectMachinePoolGrant,
|
|
48
|
+
deleteProjectModelGrant,
|
|
49
|
+
deleteSecret,
|
|
50
|
+
deleteSecretGrant,
|
|
51
|
+
deleteSkill,
|
|
52
|
+
deleteSkillGrant,
|
|
53
|
+
demoteSteeringInputToQueued,
|
|
54
|
+
endMachineDaemonRuntime,
|
|
55
|
+
getActor,
|
|
56
|
+
getAgent,
|
|
57
|
+
getAgentConfig,
|
|
58
|
+
getAgentProfile,
|
|
59
|
+
getArtifact,
|
|
60
|
+
getArtifactContent,
|
|
61
|
+
getCronTrigger,
|
|
62
|
+
getCurrentUser,
|
|
63
|
+
getDaemonSkillArchive,
|
|
64
|
+
getMachine,
|
|
65
|
+
getMachinePool,
|
|
66
|
+
getModelCatalog,
|
|
67
|
+
getModelProviderConfig,
|
|
68
|
+
getOrgApiKey,
|
|
69
|
+
getOrgOverview,
|
|
70
|
+
getProjectAvailableSecret,
|
|
71
|
+
getProjectMachinePoolGrant,
|
|
72
|
+
getSecret,
|
|
73
|
+
getSkill,
|
|
74
|
+
getToolCatalog,
|
|
75
|
+
listActors,
|
|
76
|
+
listAgentInteractions,
|
|
77
|
+
listAgentProfiles,
|
|
78
|
+
listAgents,
|
|
79
|
+
listByoMachineDaemonTokens,
|
|
80
|
+
listConfiguredModels,
|
|
81
|
+
listCronTriggers,
|
|
82
|
+
listEvents,
|
|
83
|
+
listIntegrationInstalls,
|
|
84
|
+
listMachinePools,
|
|
85
|
+
listMemberProjectAccess,
|
|
86
|
+
listModelProviderConfigs,
|
|
87
|
+
listOrgApiKeyProjectAccess,
|
|
88
|
+
listOrgApiKeys,
|
|
89
|
+
listOrgInvitations,
|
|
90
|
+
listOrgMembers,
|
|
91
|
+
listPendingInvitations,
|
|
92
|
+
listPersonalAccessTokens,
|
|
93
|
+
listProjectAvailableSecrets,
|
|
94
|
+
listProjectAvailableSkills,
|
|
95
|
+
listProjectMachineGrants,
|
|
96
|
+
listProjectMachinePoolGrants,
|
|
97
|
+
listProjectModelGrants,
|
|
98
|
+
listQueuedBacklogInputs,
|
|
99
|
+
listSecretGrants,
|
|
100
|
+
listSecrets,
|
|
101
|
+
listSkillGrants,
|
|
102
|
+
listSkills,
|
|
103
|
+
listToolCalls,
|
|
104
|
+
listTurnEvents,
|
|
105
|
+
listTurns,
|
|
106
|
+
listVisibleMachines,
|
|
107
|
+
listVisibleProjectMachines,
|
|
108
|
+
listVisibleProjects,
|
|
109
|
+
moveQueuedBacklogInput,
|
|
110
|
+
promoteQueuedInputToSteering,
|
|
111
|
+
putActor,
|
|
112
|
+
recordMachineFailure,
|
|
113
|
+
registerMachineDaemonRuntime,
|
|
114
|
+
removeMemberProjectAccess,
|
|
115
|
+
removeOrgApiKeyProjectRole,
|
|
116
|
+
removeOrgMember,
|
|
117
|
+
renameAgentProfile,
|
|
118
|
+
resolveAgentInteraction,
|
|
119
|
+
revokeMachineDaemonToken,
|
|
120
|
+
revokeOrgApiKey,
|
|
121
|
+
revokePersonalAccessToken,
|
|
122
|
+
setMemberProjectAccess,
|
|
123
|
+
setOrgApiKeyProjectRole,
|
|
124
|
+
sleepMachineDaemonRuntime,
|
|
125
|
+
socketMachineDaemonRuntime,
|
|
126
|
+
startSecretMcpoAuth,
|
|
127
|
+
submitToolCallResult,
|
|
128
|
+
updateAgentConfig,
|
|
129
|
+
updateAgentProfile,
|
|
130
|
+
updateConfiguredModel,
|
|
131
|
+
updateCronTrigger,
|
|
132
|
+
updateMachine,
|
|
133
|
+
updateMachinePool,
|
|
134
|
+
updateModelProviderConfig,
|
|
135
|
+
updateOrgApiKey,
|
|
136
|
+
updateOrgMember,
|
|
137
|
+
updateProjectMachinePoolGrant,
|
|
138
|
+
updateProjectModelGrant,
|
|
139
|
+
updateSecret
|
|
140
|
+
} from "./chunk-DGGYBF7D.js";
|
|
141
|
+
import "./chunk-CT4AUW4R.js";
|
|
142
|
+
import "./chunk-PZ5AY32C.js";
|
|
143
|
+
|
|
144
|
+
// src/generated/@tanstack/react-query.gen.ts
|
|
145
|
+
import { infiniteQueryOptions, queryOptions } from "@tanstack/react-query";
|
|
146
|
+
var createQueryKey = (id, options, infinite, tags) => {
|
|
147
|
+
const params = { _id: id, baseUrl: options?.baseUrl || (options?.client ?? client).getConfig().baseUrl };
|
|
148
|
+
if (infinite) {
|
|
149
|
+
params._infinite = infinite;
|
|
150
|
+
}
|
|
151
|
+
if (tags) {
|
|
152
|
+
params.tags = tags;
|
|
153
|
+
}
|
|
154
|
+
if (options?.body) {
|
|
155
|
+
params.body = options.body;
|
|
156
|
+
}
|
|
157
|
+
if (options?.headers) {
|
|
158
|
+
params.headers = options.headers;
|
|
159
|
+
}
|
|
160
|
+
if (options?.path) {
|
|
161
|
+
params.path = options.path;
|
|
162
|
+
}
|
|
163
|
+
if (options?.query) {
|
|
164
|
+
params.query = options.query;
|
|
165
|
+
}
|
|
166
|
+
return [params];
|
|
167
|
+
};
|
|
168
|
+
var listPersonalAccessTokensQueryKey = (options) => createQueryKey("listPersonalAccessTokens", options);
|
|
169
|
+
var listPersonalAccessTokensOptions = (options) => queryOptions({
|
|
170
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
171
|
+
const { data } = await listPersonalAccessTokens({
|
|
172
|
+
...options,
|
|
173
|
+
...queryKey[0],
|
|
174
|
+
signal,
|
|
175
|
+
throwOnError: true
|
|
176
|
+
});
|
|
177
|
+
return data;
|
|
178
|
+
},
|
|
179
|
+
queryKey: listPersonalAccessTokensQueryKey(options)
|
|
180
|
+
});
|
|
181
|
+
var createInfiniteParams = (queryKey, page) => {
|
|
182
|
+
const params = { ...queryKey[0] };
|
|
183
|
+
if (page.body) {
|
|
184
|
+
params.body = {
|
|
185
|
+
...queryKey[0].body,
|
|
186
|
+
...page.body
|
|
187
|
+
};
|
|
188
|
+
}
|
|
189
|
+
if (page.headers) {
|
|
190
|
+
params.headers = {
|
|
191
|
+
...queryKey[0].headers,
|
|
192
|
+
...page.headers
|
|
193
|
+
};
|
|
194
|
+
}
|
|
195
|
+
if (page.path) {
|
|
196
|
+
params.path = {
|
|
197
|
+
...queryKey[0].path,
|
|
198
|
+
...page.path
|
|
199
|
+
};
|
|
200
|
+
}
|
|
201
|
+
if (page.query) {
|
|
202
|
+
params.query = {
|
|
203
|
+
...queryKey[0].query,
|
|
204
|
+
...page.query
|
|
205
|
+
};
|
|
206
|
+
}
|
|
207
|
+
return params;
|
|
208
|
+
};
|
|
209
|
+
var listPersonalAccessTokensInfiniteQueryKey = (options) => createQueryKey("listPersonalAccessTokens", options, true);
|
|
210
|
+
var listPersonalAccessTokensInfiniteOptions = (options) => {
|
|
211
|
+
const opts = infiniteQueryOptions(
|
|
212
|
+
// @ts-ignore
|
|
213
|
+
{
|
|
214
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
215
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
216
|
+
query: {
|
|
217
|
+
cursor: pageParam
|
|
218
|
+
}
|
|
219
|
+
};
|
|
220
|
+
const params = createInfiniteParams(queryKey, page);
|
|
221
|
+
const { data } = await listPersonalAccessTokens({
|
|
222
|
+
...options,
|
|
223
|
+
...params,
|
|
224
|
+
signal,
|
|
225
|
+
throwOnError: true
|
|
226
|
+
});
|
|
227
|
+
return data;
|
|
228
|
+
},
|
|
229
|
+
queryKey: listPersonalAccessTokensInfiniteQueryKey(options)
|
|
230
|
+
}
|
|
231
|
+
);
|
|
232
|
+
return opts;
|
|
233
|
+
};
|
|
234
|
+
var createPersonalAccessTokenMutation = (options) => {
|
|
235
|
+
const mutationOptions = {
|
|
236
|
+
mutationFn: async (fnOptions) => {
|
|
237
|
+
const { data } = await createPersonalAccessToken({
|
|
238
|
+
...options,
|
|
239
|
+
...fnOptions,
|
|
240
|
+
throwOnError: true
|
|
241
|
+
});
|
|
242
|
+
return data;
|
|
243
|
+
}
|
|
244
|
+
};
|
|
245
|
+
return mutationOptions;
|
|
246
|
+
};
|
|
247
|
+
var revokePersonalAccessTokenMutation = (options) => {
|
|
248
|
+
const mutationOptions = {
|
|
249
|
+
mutationFn: async (fnOptions) => {
|
|
250
|
+
const { data } = await revokePersonalAccessToken({
|
|
251
|
+
...options,
|
|
252
|
+
...fnOptions,
|
|
253
|
+
throwOnError: true
|
|
254
|
+
});
|
|
255
|
+
return data;
|
|
256
|
+
}
|
|
257
|
+
};
|
|
258
|
+
return mutationOptions;
|
|
259
|
+
};
|
|
260
|
+
var bootstrapDaemonMutation = (options) => {
|
|
261
|
+
const mutationOptions = {
|
|
262
|
+
mutationFn: async (fnOptions) => {
|
|
263
|
+
const { data } = await bootstrapDaemon({
|
|
264
|
+
...options,
|
|
265
|
+
...fnOptions,
|
|
266
|
+
throwOnError: true
|
|
267
|
+
});
|
|
268
|
+
return data;
|
|
269
|
+
}
|
|
270
|
+
};
|
|
271
|
+
return mutationOptions;
|
|
272
|
+
};
|
|
273
|
+
var recordMachineFailureMutation = (options) => {
|
|
274
|
+
const mutationOptions = {
|
|
275
|
+
mutationFn: async (fnOptions) => {
|
|
276
|
+
const { data } = await recordMachineFailure({
|
|
277
|
+
...options,
|
|
278
|
+
...fnOptions,
|
|
279
|
+
throwOnError: true
|
|
280
|
+
});
|
|
281
|
+
return data;
|
|
282
|
+
}
|
|
283
|
+
};
|
|
284
|
+
return mutationOptions;
|
|
285
|
+
};
|
|
286
|
+
var createOrganizationMutation = (options) => {
|
|
287
|
+
const mutationOptions = {
|
|
288
|
+
mutationFn: async (fnOptions) => {
|
|
289
|
+
const { data } = await createOrganization({
|
|
290
|
+
...options,
|
|
291
|
+
...fnOptions,
|
|
292
|
+
throwOnError: true
|
|
293
|
+
});
|
|
294
|
+
return data;
|
|
295
|
+
}
|
|
296
|
+
};
|
|
297
|
+
return mutationOptions;
|
|
298
|
+
};
|
|
299
|
+
var deleteOrganizationMutation = (options) => {
|
|
300
|
+
const mutationOptions = {
|
|
301
|
+
mutationFn: async (fnOptions) => {
|
|
302
|
+
const { data } = await deleteOrganization({
|
|
303
|
+
...options,
|
|
304
|
+
...fnOptions,
|
|
305
|
+
throwOnError: true
|
|
306
|
+
});
|
|
307
|
+
return data;
|
|
308
|
+
}
|
|
309
|
+
};
|
|
310
|
+
return mutationOptions;
|
|
311
|
+
};
|
|
312
|
+
var deleteCurrentUserMutation = (options) => {
|
|
313
|
+
const mutationOptions = {
|
|
314
|
+
mutationFn: async (fnOptions) => {
|
|
315
|
+
const { data } = await deleteCurrentUser({
|
|
316
|
+
...options,
|
|
317
|
+
...fnOptions,
|
|
318
|
+
throwOnError: true
|
|
319
|
+
});
|
|
320
|
+
return data;
|
|
321
|
+
}
|
|
322
|
+
};
|
|
323
|
+
return mutationOptions;
|
|
324
|
+
};
|
|
325
|
+
var getCurrentUserQueryKey = (options) => createQueryKey("getCurrentUser", options);
|
|
326
|
+
var getCurrentUserOptions = (options) => queryOptions({
|
|
327
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
328
|
+
const { data } = await getCurrentUser({
|
|
329
|
+
...options,
|
|
330
|
+
...queryKey[0],
|
|
331
|
+
signal,
|
|
332
|
+
throwOnError: true
|
|
333
|
+
});
|
|
334
|
+
return data;
|
|
335
|
+
},
|
|
336
|
+
queryKey: getCurrentUserQueryKey(options)
|
|
337
|
+
});
|
|
338
|
+
var listPendingInvitationsQueryKey = (options) => createQueryKey("listPendingInvitations", options);
|
|
339
|
+
var listPendingInvitationsOptions = (options) => queryOptions({
|
|
340
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
341
|
+
const { data } = await listPendingInvitations({
|
|
342
|
+
...options,
|
|
343
|
+
...queryKey[0],
|
|
344
|
+
signal,
|
|
345
|
+
throwOnError: true
|
|
346
|
+
});
|
|
347
|
+
return data;
|
|
348
|
+
},
|
|
349
|
+
queryKey: listPendingInvitationsQueryKey(options)
|
|
350
|
+
});
|
|
351
|
+
var listPendingInvitationsInfiniteQueryKey = (options) => createQueryKey("listPendingInvitations", options, true);
|
|
352
|
+
var listPendingInvitationsInfiniteOptions = (options) => {
|
|
353
|
+
const opts = infiniteQueryOptions(
|
|
354
|
+
// @ts-ignore
|
|
355
|
+
{
|
|
356
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
357
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
358
|
+
query: {
|
|
359
|
+
cursor: pageParam
|
|
360
|
+
}
|
|
361
|
+
};
|
|
362
|
+
const params = createInfiniteParams(queryKey, page);
|
|
363
|
+
const { data } = await listPendingInvitations({
|
|
364
|
+
...options,
|
|
365
|
+
...params,
|
|
366
|
+
signal,
|
|
367
|
+
throwOnError: true
|
|
368
|
+
});
|
|
369
|
+
return data;
|
|
370
|
+
},
|
|
371
|
+
queryKey: listPendingInvitationsInfiniteQueryKey(options)
|
|
372
|
+
}
|
|
373
|
+
);
|
|
374
|
+
return opts;
|
|
375
|
+
};
|
|
376
|
+
var acceptInvitationMutation = (options) => {
|
|
377
|
+
const mutationOptions = {
|
|
378
|
+
mutationFn: async (fnOptions) => {
|
|
379
|
+
const { data } = await acceptInvitation({
|
|
380
|
+
...options,
|
|
381
|
+
...fnOptions,
|
|
382
|
+
throwOnError: true
|
|
383
|
+
});
|
|
384
|
+
return data;
|
|
385
|
+
}
|
|
386
|
+
};
|
|
387
|
+
return mutationOptions;
|
|
388
|
+
};
|
|
389
|
+
var declineInvitationMutation = (options) => {
|
|
390
|
+
const mutationOptions = {
|
|
391
|
+
mutationFn: async (fnOptions) => {
|
|
392
|
+
const { data } = await declineInvitation({
|
|
393
|
+
...options,
|
|
394
|
+
...fnOptions,
|
|
395
|
+
throwOnError: true
|
|
396
|
+
});
|
|
397
|
+
return data;
|
|
398
|
+
}
|
|
399
|
+
};
|
|
400
|
+
return mutationOptions;
|
|
401
|
+
};
|
|
402
|
+
var getOrgOverviewQueryKey = (options) => createQueryKey("getOrgOverview", options);
|
|
403
|
+
var getOrgOverviewOptions = (options) => queryOptions({
|
|
404
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
405
|
+
const { data } = await getOrgOverview({
|
|
406
|
+
...options,
|
|
407
|
+
...queryKey[0],
|
|
408
|
+
signal,
|
|
409
|
+
throwOnError: true
|
|
410
|
+
});
|
|
411
|
+
return data;
|
|
412
|
+
},
|
|
413
|
+
queryKey: getOrgOverviewQueryKey(options)
|
|
414
|
+
});
|
|
415
|
+
var listVisibleProjectsQueryKey = (options) => createQueryKey("listVisibleProjects", options);
|
|
416
|
+
var listVisibleProjectsOptions = (options) => queryOptions({
|
|
417
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
418
|
+
const { data } = await listVisibleProjects({
|
|
419
|
+
...options,
|
|
420
|
+
...queryKey[0],
|
|
421
|
+
signal,
|
|
422
|
+
throwOnError: true
|
|
423
|
+
});
|
|
424
|
+
return data;
|
|
425
|
+
},
|
|
426
|
+
queryKey: listVisibleProjectsQueryKey(options)
|
|
427
|
+
});
|
|
428
|
+
var listVisibleProjectsInfiniteQueryKey = (options) => createQueryKey("listVisibleProjects", options, true);
|
|
429
|
+
var listVisibleProjectsInfiniteOptions = (options) => {
|
|
430
|
+
const opts = infiniteQueryOptions(
|
|
431
|
+
// @ts-ignore
|
|
432
|
+
{
|
|
433
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
434
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
435
|
+
query: {
|
|
436
|
+
cursor: pageParam
|
|
437
|
+
}
|
|
438
|
+
};
|
|
439
|
+
const params = createInfiniteParams(queryKey, page);
|
|
440
|
+
const { data } = await listVisibleProjects({
|
|
441
|
+
...options,
|
|
442
|
+
...params,
|
|
443
|
+
signal,
|
|
444
|
+
throwOnError: true
|
|
445
|
+
});
|
|
446
|
+
return data;
|
|
447
|
+
},
|
|
448
|
+
queryKey: listVisibleProjectsInfiniteQueryKey(options)
|
|
449
|
+
}
|
|
450
|
+
);
|
|
451
|
+
return opts;
|
|
452
|
+
};
|
|
453
|
+
var createProjectMutation = (options) => {
|
|
454
|
+
const mutationOptions = {
|
|
455
|
+
mutationFn: async (fnOptions) => {
|
|
456
|
+
const { data } = await createProject({
|
|
457
|
+
...options,
|
|
458
|
+
...fnOptions,
|
|
459
|
+
throwOnError: true
|
|
460
|
+
});
|
|
461
|
+
return data;
|
|
462
|
+
}
|
|
463
|
+
};
|
|
464
|
+
return mutationOptions;
|
|
465
|
+
};
|
|
466
|
+
var deleteProjectMutation = (options) => {
|
|
467
|
+
const mutationOptions = {
|
|
468
|
+
mutationFn: async (fnOptions) => {
|
|
469
|
+
const { data } = await deleteProject({
|
|
470
|
+
...options,
|
|
471
|
+
...fnOptions,
|
|
472
|
+
throwOnError: true
|
|
473
|
+
});
|
|
474
|
+
return data;
|
|
475
|
+
}
|
|
476
|
+
};
|
|
477
|
+
return mutationOptions;
|
|
478
|
+
};
|
|
479
|
+
var listOrgMembersQueryKey = (options) => createQueryKey("listOrgMembers", options);
|
|
480
|
+
var listOrgMembersOptions = (options) => queryOptions({
|
|
481
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
482
|
+
const { data } = await listOrgMembers({
|
|
483
|
+
...options,
|
|
484
|
+
...queryKey[0],
|
|
485
|
+
signal,
|
|
486
|
+
throwOnError: true
|
|
487
|
+
});
|
|
488
|
+
return data;
|
|
489
|
+
},
|
|
490
|
+
queryKey: listOrgMembersQueryKey(options)
|
|
491
|
+
});
|
|
492
|
+
var listOrgMembersInfiniteQueryKey = (options) => createQueryKey("listOrgMembers", options, true);
|
|
493
|
+
var listOrgMembersInfiniteOptions = (options) => {
|
|
494
|
+
const opts = infiniteQueryOptions(
|
|
495
|
+
// @ts-ignore
|
|
496
|
+
{
|
|
497
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
498
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
499
|
+
query: {
|
|
500
|
+
cursor: pageParam
|
|
501
|
+
}
|
|
502
|
+
};
|
|
503
|
+
const params = createInfiniteParams(queryKey, page);
|
|
504
|
+
const { data } = await listOrgMembers({
|
|
505
|
+
...options,
|
|
506
|
+
...params,
|
|
507
|
+
signal,
|
|
508
|
+
throwOnError: true
|
|
509
|
+
});
|
|
510
|
+
return data;
|
|
511
|
+
},
|
|
512
|
+
queryKey: listOrgMembersInfiniteQueryKey(options)
|
|
513
|
+
}
|
|
514
|
+
);
|
|
515
|
+
return opts;
|
|
516
|
+
};
|
|
517
|
+
var removeOrgMemberMutation = (options) => {
|
|
518
|
+
const mutationOptions = {
|
|
519
|
+
mutationFn: async (fnOptions) => {
|
|
520
|
+
const { data } = await removeOrgMember({
|
|
521
|
+
...options,
|
|
522
|
+
...fnOptions,
|
|
523
|
+
throwOnError: true
|
|
524
|
+
});
|
|
525
|
+
return data;
|
|
526
|
+
}
|
|
527
|
+
};
|
|
528
|
+
return mutationOptions;
|
|
529
|
+
};
|
|
530
|
+
var updateOrgMemberMutation = (options) => {
|
|
531
|
+
const mutationOptions = {
|
|
532
|
+
mutationFn: async (fnOptions) => {
|
|
533
|
+
const { data } = await updateOrgMember({
|
|
534
|
+
...options,
|
|
535
|
+
...fnOptions,
|
|
536
|
+
throwOnError: true
|
|
537
|
+
});
|
|
538
|
+
return data;
|
|
539
|
+
}
|
|
540
|
+
};
|
|
541
|
+
return mutationOptions;
|
|
542
|
+
};
|
|
543
|
+
var listMemberProjectAccessQueryKey = (options) => createQueryKey("listMemberProjectAccess", options);
|
|
544
|
+
var listMemberProjectAccessOptions = (options) => queryOptions({
|
|
545
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
546
|
+
const { data } = await listMemberProjectAccess({
|
|
547
|
+
...options,
|
|
548
|
+
...queryKey[0],
|
|
549
|
+
signal,
|
|
550
|
+
throwOnError: true
|
|
551
|
+
});
|
|
552
|
+
return data;
|
|
553
|
+
},
|
|
554
|
+
queryKey: listMemberProjectAccessQueryKey(options)
|
|
555
|
+
});
|
|
556
|
+
var removeMemberProjectAccessMutation = (options) => {
|
|
557
|
+
const mutationOptions = {
|
|
558
|
+
mutationFn: async (fnOptions) => {
|
|
559
|
+
const { data } = await removeMemberProjectAccess({
|
|
560
|
+
...options,
|
|
561
|
+
...fnOptions,
|
|
562
|
+
throwOnError: true
|
|
563
|
+
});
|
|
564
|
+
return data;
|
|
565
|
+
}
|
|
566
|
+
};
|
|
567
|
+
return mutationOptions;
|
|
568
|
+
};
|
|
569
|
+
var setMemberProjectAccessMutation = (options) => {
|
|
570
|
+
const mutationOptions = {
|
|
571
|
+
mutationFn: async (fnOptions) => {
|
|
572
|
+
const { data } = await setMemberProjectAccess({
|
|
573
|
+
...options,
|
|
574
|
+
...fnOptions,
|
|
575
|
+
throwOnError: true
|
|
576
|
+
});
|
|
577
|
+
return data;
|
|
578
|
+
}
|
|
579
|
+
};
|
|
580
|
+
return mutationOptions;
|
|
581
|
+
};
|
|
582
|
+
var listOrgApiKeysQueryKey = (options) => createQueryKey("listOrgApiKeys", options);
|
|
583
|
+
var listOrgApiKeysOptions = (options) => queryOptions({
|
|
584
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
585
|
+
const { data } = await listOrgApiKeys({
|
|
586
|
+
...options,
|
|
587
|
+
...queryKey[0],
|
|
588
|
+
signal,
|
|
589
|
+
throwOnError: true
|
|
590
|
+
});
|
|
591
|
+
return data;
|
|
592
|
+
},
|
|
593
|
+
queryKey: listOrgApiKeysQueryKey(options)
|
|
594
|
+
});
|
|
595
|
+
var listOrgApiKeysInfiniteQueryKey = (options) => createQueryKey("listOrgApiKeys", options, true);
|
|
596
|
+
var listOrgApiKeysInfiniteOptions = (options) => {
|
|
597
|
+
const opts = infiniteQueryOptions(
|
|
598
|
+
// @ts-ignore
|
|
599
|
+
{
|
|
600
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
601
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
602
|
+
query: {
|
|
603
|
+
cursor: pageParam
|
|
604
|
+
}
|
|
605
|
+
};
|
|
606
|
+
const params = createInfiniteParams(queryKey, page);
|
|
607
|
+
const { data } = await listOrgApiKeys({
|
|
608
|
+
...options,
|
|
609
|
+
...params,
|
|
610
|
+
signal,
|
|
611
|
+
throwOnError: true
|
|
612
|
+
});
|
|
613
|
+
return data;
|
|
614
|
+
},
|
|
615
|
+
queryKey: listOrgApiKeysInfiniteQueryKey(options)
|
|
616
|
+
}
|
|
617
|
+
);
|
|
618
|
+
return opts;
|
|
619
|
+
};
|
|
620
|
+
var createOrgApiKeyMutation = (options) => {
|
|
621
|
+
const mutationOptions = {
|
|
622
|
+
mutationFn: async (fnOptions) => {
|
|
623
|
+
const { data } = await createOrgApiKey({
|
|
624
|
+
...options,
|
|
625
|
+
...fnOptions,
|
|
626
|
+
throwOnError: true
|
|
627
|
+
});
|
|
628
|
+
return data;
|
|
629
|
+
}
|
|
630
|
+
};
|
|
631
|
+
return mutationOptions;
|
|
632
|
+
};
|
|
633
|
+
var getOrgApiKeyQueryKey = (options) => createQueryKey("getOrgApiKey", options);
|
|
634
|
+
var getOrgApiKeyOptions = (options) => queryOptions({
|
|
635
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
636
|
+
const { data } = await getOrgApiKey({
|
|
637
|
+
...options,
|
|
638
|
+
...queryKey[0],
|
|
639
|
+
signal,
|
|
640
|
+
throwOnError: true
|
|
641
|
+
});
|
|
642
|
+
return data;
|
|
643
|
+
},
|
|
644
|
+
queryKey: getOrgApiKeyQueryKey(options)
|
|
645
|
+
});
|
|
646
|
+
var updateOrgApiKeyMutation = (options) => {
|
|
647
|
+
const mutationOptions = {
|
|
648
|
+
mutationFn: async (fnOptions) => {
|
|
649
|
+
const { data } = await updateOrgApiKey({
|
|
650
|
+
...options,
|
|
651
|
+
...fnOptions,
|
|
652
|
+
throwOnError: true
|
|
653
|
+
});
|
|
654
|
+
return data;
|
|
655
|
+
}
|
|
656
|
+
};
|
|
657
|
+
return mutationOptions;
|
|
658
|
+
};
|
|
659
|
+
var revokeOrgApiKeyMutation = (options) => {
|
|
660
|
+
const mutationOptions = {
|
|
661
|
+
mutationFn: async (fnOptions) => {
|
|
662
|
+
const { data } = await revokeOrgApiKey({
|
|
663
|
+
...options,
|
|
664
|
+
...fnOptions,
|
|
665
|
+
throwOnError: true
|
|
666
|
+
});
|
|
667
|
+
return data;
|
|
668
|
+
}
|
|
669
|
+
};
|
|
670
|
+
return mutationOptions;
|
|
671
|
+
};
|
|
672
|
+
var listOrgApiKeyProjectAccessQueryKey = (options) => createQueryKey("listOrgApiKeyProjectAccess", options);
|
|
673
|
+
var listOrgApiKeyProjectAccessOptions = (options) => queryOptions({
|
|
674
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
675
|
+
const { data } = await listOrgApiKeyProjectAccess({
|
|
676
|
+
...options,
|
|
677
|
+
...queryKey[0],
|
|
678
|
+
signal,
|
|
679
|
+
throwOnError: true
|
|
680
|
+
});
|
|
681
|
+
return data;
|
|
682
|
+
},
|
|
683
|
+
queryKey: listOrgApiKeyProjectAccessQueryKey(options)
|
|
684
|
+
});
|
|
685
|
+
var removeOrgApiKeyProjectRoleMutation = (options) => {
|
|
686
|
+
const mutationOptions = {
|
|
687
|
+
mutationFn: async (fnOptions) => {
|
|
688
|
+
const { data } = await removeOrgApiKeyProjectRole({
|
|
689
|
+
...options,
|
|
690
|
+
...fnOptions,
|
|
691
|
+
throwOnError: true
|
|
692
|
+
});
|
|
693
|
+
return data;
|
|
694
|
+
}
|
|
695
|
+
};
|
|
696
|
+
return mutationOptions;
|
|
697
|
+
};
|
|
698
|
+
var setOrgApiKeyProjectRoleMutation = (options) => {
|
|
699
|
+
const mutationOptions = {
|
|
700
|
+
mutationFn: async (fnOptions) => {
|
|
701
|
+
const { data } = await setOrgApiKeyProjectRole({
|
|
702
|
+
...options,
|
|
703
|
+
...fnOptions,
|
|
704
|
+
throwOnError: true
|
|
705
|
+
});
|
|
706
|
+
return data;
|
|
707
|
+
}
|
|
708
|
+
};
|
|
709
|
+
return mutationOptions;
|
|
710
|
+
};
|
|
711
|
+
var listOrgInvitationsQueryKey = (options) => createQueryKey("listOrgInvitations", options);
|
|
712
|
+
var listOrgInvitationsOptions = (options) => queryOptions({
|
|
713
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
714
|
+
const { data } = await listOrgInvitations({
|
|
715
|
+
...options,
|
|
716
|
+
...queryKey[0],
|
|
717
|
+
signal,
|
|
718
|
+
throwOnError: true
|
|
719
|
+
});
|
|
720
|
+
return data;
|
|
721
|
+
},
|
|
722
|
+
queryKey: listOrgInvitationsQueryKey(options)
|
|
723
|
+
});
|
|
724
|
+
var listOrgInvitationsInfiniteQueryKey = (options) => createQueryKey("listOrgInvitations", options, true);
|
|
725
|
+
var listOrgInvitationsInfiniteOptions = (options) => {
|
|
726
|
+
const opts = infiniteQueryOptions(
|
|
727
|
+
// @ts-ignore
|
|
728
|
+
{
|
|
729
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
730
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
731
|
+
query: {
|
|
732
|
+
cursor: pageParam
|
|
733
|
+
}
|
|
734
|
+
};
|
|
735
|
+
const params = createInfiniteParams(queryKey, page);
|
|
736
|
+
const { data } = await listOrgInvitations({
|
|
737
|
+
...options,
|
|
738
|
+
...params,
|
|
739
|
+
signal,
|
|
740
|
+
throwOnError: true
|
|
741
|
+
});
|
|
742
|
+
return data;
|
|
743
|
+
},
|
|
744
|
+
queryKey: listOrgInvitationsInfiniteQueryKey(options)
|
|
745
|
+
}
|
|
746
|
+
);
|
|
747
|
+
return opts;
|
|
748
|
+
};
|
|
749
|
+
var createOrgInvitationMutation = (options) => {
|
|
750
|
+
const mutationOptions = {
|
|
751
|
+
mutationFn: async (fnOptions) => {
|
|
752
|
+
const { data } = await createOrgInvitation({
|
|
753
|
+
...options,
|
|
754
|
+
...fnOptions,
|
|
755
|
+
throwOnError: true
|
|
756
|
+
});
|
|
757
|
+
return data;
|
|
758
|
+
}
|
|
759
|
+
};
|
|
760
|
+
return mutationOptions;
|
|
761
|
+
};
|
|
762
|
+
var deleteOrgInvitationMutation = (options) => {
|
|
763
|
+
const mutationOptions = {
|
|
764
|
+
mutationFn: async (fnOptions) => {
|
|
765
|
+
const { data } = await deleteOrgInvitation({
|
|
766
|
+
...options,
|
|
767
|
+
...fnOptions,
|
|
768
|
+
throwOnError: true
|
|
769
|
+
});
|
|
770
|
+
return data;
|
|
771
|
+
}
|
|
772
|
+
};
|
|
773
|
+
return mutationOptions;
|
|
774
|
+
};
|
|
775
|
+
var listSkillsQueryKey = (options) => createQueryKey("listSkills", options);
|
|
776
|
+
var listSkillsOptions = (options) => queryOptions({
|
|
777
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
778
|
+
const { data } = await listSkills({
|
|
779
|
+
...options,
|
|
780
|
+
...queryKey[0],
|
|
781
|
+
signal,
|
|
782
|
+
throwOnError: true
|
|
783
|
+
});
|
|
784
|
+
return data;
|
|
785
|
+
},
|
|
786
|
+
queryKey: listSkillsQueryKey(options)
|
|
787
|
+
});
|
|
788
|
+
var listSkillsInfiniteQueryKey = (options) => createQueryKey("listSkills", options, true);
|
|
789
|
+
var listSkillsInfiniteOptions = (options) => {
|
|
790
|
+
const opts = infiniteQueryOptions(
|
|
791
|
+
// @ts-ignore
|
|
792
|
+
{
|
|
793
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
794
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
795
|
+
query: {
|
|
796
|
+
cursor: pageParam
|
|
797
|
+
}
|
|
798
|
+
};
|
|
799
|
+
const params = createInfiniteParams(queryKey, page);
|
|
800
|
+
const { data } = await listSkills({
|
|
801
|
+
...options,
|
|
802
|
+
...params,
|
|
803
|
+
signal,
|
|
804
|
+
throwOnError: true
|
|
805
|
+
});
|
|
806
|
+
return data;
|
|
807
|
+
},
|
|
808
|
+
queryKey: listSkillsInfiniteQueryKey(options)
|
|
809
|
+
}
|
|
810
|
+
);
|
|
811
|
+
return opts;
|
|
812
|
+
};
|
|
813
|
+
var createSkillMutation = (options) => {
|
|
814
|
+
const mutationOptions = {
|
|
815
|
+
mutationFn: async (fnOptions) => {
|
|
816
|
+
const { data } = await createSkill({
|
|
817
|
+
...options,
|
|
818
|
+
...fnOptions,
|
|
819
|
+
throwOnError: true
|
|
820
|
+
});
|
|
821
|
+
return data;
|
|
822
|
+
}
|
|
823
|
+
};
|
|
824
|
+
return mutationOptions;
|
|
825
|
+
};
|
|
826
|
+
var deleteSkillMutation = (options) => {
|
|
827
|
+
const mutationOptions = {
|
|
828
|
+
mutationFn: async (fnOptions) => {
|
|
829
|
+
const { data } = await deleteSkill({
|
|
830
|
+
...options,
|
|
831
|
+
...fnOptions,
|
|
832
|
+
throwOnError: true
|
|
833
|
+
});
|
|
834
|
+
return data;
|
|
835
|
+
}
|
|
836
|
+
};
|
|
837
|
+
return mutationOptions;
|
|
838
|
+
};
|
|
839
|
+
var getSkillQueryKey = (options) => createQueryKey("getSkill", options);
|
|
840
|
+
var getSkillOptions = (options) => queryOptions({
|
|
841
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
842
|
+
const { data } = await getSkill({
|
|
843
|
+
...options,
|
|
844
|
+
...queryKey[0],
|
|
845
|
+
signal,
|
|
846
|
+
throwOnError: true
|
|
847
|
+
});
|
|
848
|
+
return data;
|
|
849
|
+
},
|
|
850
|
+
queryKey: getSkillQueryKey(options)
|
|
851
|
+
});
|
|
852
|
+
var listSkillGrantsQueryKey = (options) => createQueryKey("listSkillGrants", options);
|
|
853
|
+
var listSkillGrantsOptions = (options) => queryOptions({
|
|
854
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
855
|
+
const { data } = await listSkillGrants({
|
|
856
|
+
...options,
|
|
857
|
+
...queryKey[0],
|
|
858
|
+
signal,
|
|
859
|
+
throwOnError: true
|
|
860
|
+
});
|
|
861
|
+
return data;
|
|
862
|
+
},
|
|
863
|
+
queryKey: listSkillGrantsQueryKey(options)
|
|
864
|
+
});
|
|
865
|
+
var listSkillGrantsInfiniteQueryKey = (options) => createQueryKey("listSkillGrants", options, true);
|
|
866
|
+
var listSkillGrantsInfiniteOptions = (options) => {
|
|
867
|
+
const opts = infiniteQueryOptions(
|
|
868
|
+
// @ts-ignore
|
|
869
|
+
{
|
|
870
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
871
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
872
|
+
query: {
|
|
873
|
+
cursor: pageParam
|
|
874
|
+
}
|
|
875
|
+
};
|
|
876
|
+
const params = createInfiniteParams(queryKey, page);
|
|
877
|
+
const { data } = await listSkillGrants({
|
|
878
|
+
...options,
|
|
879
|
+
...params,
|
|
880
|
+
signal,
|
|
881
|
+
throwOnError: true
|
|
882
|
+
});
|
|
883
|
+
return data;
|
|
884
|
+
},
|
|
885
|
+
queryKey: listSkillGrantsInfiniteQueryKey(options)
|
|
886
|
+
}
|
|
887
|
+
);
|
|
888
|
+
return opts;
|
|
889
|
+
};
|
|
890
|
+
var createSkillGrantMutation = (options) => {
|
|
891
|
+
const mutationOptions = {
|
|
892
|
+
mutationFn: async (fnOptions) => {
|
|
893
|
+
const { data } = await createSkillGrant({
|
|
894
|
+
...options,
|
|
895
|
+
...fnOptions,
|
|
896
|
+
throwOnError: true
|
|
897
|
+
});
|
|
898
|
+
return data;
|
|
899
|
+
}
|
|
900
|
+
};
|
|
901
|
+
return mutationOptions;
|
|
902
|
+
};
|
|
903
|
+
var deleteSkillGrantMutation = (options) => {
|
|
904
|
+
const mutationOptions = {
|
|
905
|
+
mutationFn: async (fnOptions) => {
|
|
906
|
+
const { data } = await deleteSkillGrant({
|
|
907
|
+
...options,
|
|
908
|
+
...fnOptions,
|
|
909
|
+
throwOnError: true
|
|
910
|
+
});
|
|
911
|
+
return data;
|
|
912
|
+
}
|
|
913
|
+
};
|
|
914
|
+
return mutationOptions;
|
|
915
|
+
};
|
|
916
|
+
var listProjectAvailableSkillsQueryKey = (options) => createQueryKey("listProjectAvailableSkills", options);
|
|
917
|
+
var listProjectAvailableSkillsOptions = (options) => queryOptions({
|
|
918
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
919
|
+
const { data } = await listProjectAvailableSkills({
|
|
920
|
+
...options,
|
|
921
|
+
...queryKey[0],
|
|
922
|
+
signal,
|
|
923
|
+
throwOnError: true
|
|
924
|
+
});
|
|
925
|
+
return data;
|
|
926
|
+
},
|
|
927
|
+
queryKey: listProjectAvailableSkillsQueryKey(options)
|
|
928
|
+
});
|
|
929
|
+
var listProjectAvailableSkillsInfiniteQueryKey = (options) => createQueryKey("listProjectAvailableSkills", options, true);
|
|
930
|
+
var listProjectAvailableSkillsInfiniteOptions = (options) => {
|
|
931
|
+
const opts = infiniteQueryOptions(
|
|
932
|
+
// @ts-ignore
|
|
933
|
+
{
|
|
934
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
935
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
936
|
+
query: {
|
|
937
|
+
cursor: pageParam
|
|
938
|
+
}
|
|
939
|
+
};
|
|
940
|
+
const params = createInfiniteParams(queryKey, page);
|
|
941
|
+
const { data } = await listProjectAvailableSkills({
|
|
942
|
+
...options,
|
|
943
|
+
...params,
|
|
944
|
+
signal,
|
|
945
|
+
throwOnError: true
|
|
946
|
+
});
|
|
947
|
+
return data;
|
|
948
|
+
},
|
|
949
|
+
queryKey: listProjectAvailableSkillsInfiniteQueryKey(options)
|
|
950
|
+
}
|
|
951
|
+
);
|
|
952
|
+
return opts;
|
|
953
|
+
};
|
|
954
|
+
var listSecretsQueryKey = (options) => createQueryKey("listSecrets", options);
|
|
955
|
+
var listSecretsOptions = (options) => queryOptions({
|
|
956
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
957
|
+
const { data } = await listSecrets({
|
|
958
|
+
...options,
|
|
959
|
+
...queryKey[0],
|
|
960
|
+
signal,
|
|
961
|
+
throwOnError: true
|
|
962
|
+
});
|
|
963
|
+
return data;
|
|
964
|
+
},
|
|
965
|
+
queryKey: listSecretsQueryKey(options)
|
|
966
|
+
});
|
|
967
|
+
var listSecretsInfiniteQueryKey = (options) => createQueryKey("listSecrets", options, true);
|
|
968
|
+
var listSecretsInfiniteOptions = (options) => {
|
|
969
|
+
const opts = infiniteQueryOptions(
|
|
970
|
+
// @ts-ignore
|
|
971
|
+
{
|
|
972
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
973
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
974
|
+
query: {
|
|
975
|
+
cursor: pageParam
|
|
976
|
+
}
|
|
977
|
+
};
|
|
978
|
+
const params = createInfiniteParams(queryKey, page);
|
|
979
|
+
const { data } = await listSecrets({
|
|
980
|
+
...options,
|
|
981
|
+
...params,
|
|
982
|
+
signal,
|
|
983
|
+
throwOnError: true
|
|
984
|
+
});
|
|
985
|
+
return data;
|
|
986
|
+
},
|
|
987
|
+
queryKey: listSecretsInfiniteQueryKey(options)
|
|
988
|
+
}
|
|
989
|
+
);
|
|
990
|
+
return opts;
|
|
991
|
+
};
|
|
992
|
+
var createSecretMutation = (options) => {
|
|
993
|
+
const mutationOptions = {
|
|
994
|
+
mutationFn: async (fnOptions) => {
|
|
995
|
+
const { data } = await createSecret({
|
|
996
|
+
...options,
|
|
997
|
+
...fnOptions,
|
|
998
|
+
throwOnError: true
|
|
999
|
+
});
|
|
1000
|
+
return data;
|
|
1001
|
+
}
|
|
1002
|
+
};
|
|
1003
|
+
return mutationOptions;
|
|
1004
|
+
};
|
|
1005
|
+
var startSecretMcpoAuthMutation = (options) => {
|
|
1006
|
+
const mutationOptions = {
|
|
1007
|
+
mutationFn: async (fnOptions) => {
|
|
1008
|
+
const { data } = await startSecretMcpoAuth({
|
|
1009
|
+
...options,
|
|
1010
|
+
...fnOptions,
|
|
1011
|
+
throwOnError: true
|
|
1012
|
+
});
|
|
1013
|
+
return data;
|
|
1014
|
+
}
|
|
1015
|
+
};
|
|
1016
|
+
return mutationOptions;
|
|
1017
|
+
};
|
|
1018
|
+
var deleteSecretMutation = (options) => {
|
|
1019
|
+
const mutationOptions = {
|
|
1020
|
+
mutationFn: async (fnOptions) => {
|
|
1021
|
+
const { data } = await deleteSecret({
|
|
1022
|
+
...options,
|
|
1023
|
+
...fnOptions,
|
|
1024
|
+
throwOnError: true
|
|
1025
|
+
});
|
|
1026
|
+
return data;
|
|
1027
|
+
}
|
|
1028
|
+
};
|
|
1029
|
+
return mutationOptions;
|
|
1030
|
+
};
|
|
1031
|
+
var getSecretQueryKey = (options) => createQueryKey("getSecret", options);
|
|
1032
|
+
var getSecretOptions = (options) => queryOptions({
|
|
1033
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1034
|
+
const { data } = await getSecret({
|
|
1035
|
+
...options,
|
|
1036
|
+
...queryKey[0],
|
|
1037
|
+
signal,
|
|
1038
|
+
throwOnError: true
|
|
1039
|
+
});
|
|
1040
|
+
return data;
|
|
1041
|
+
},
|
|
1042
|
+
queryKey: getSecretQueryKey(options)
|
|
1043
|
+
});
|
|
1044
|
+
var updateSecretMutation = (options) => {
|
|
1045
|
+
const mutationOptions = {
|
|
1046
|
+
mutationFn: async (fnOptions) => {
|
|
1047
|
+
const { data } = await updateSecret({
|
|
1048
|
+
...options,
|
|
1049
|
+
...fnOptions,
|
|
1050
|
+
throwOnError: true
|
|
1051
|
+
});
|
|
1052
|
+
return data;
|
|
1053
|
+
}
|
|
1054
|
+
};
|
|
1055
|
+
return mutationOptions;
|
|
1056
|
+
};
|
|
1057
|
+
var createSecretVersionMutation = (options) => {
|
|
1058
|
+
const mutationOptions = {
|
|
1059
|
+
mutationFn: async (fnOptions) => {
|
|
1060
|
+
const { data } = await createSecretVersion({
|
|
1061
|
+
...options,
|
|
1062
|
+
...fnOptions,
|
|
1063
|
+
throwOnError: true
|
|
1064
|
+
});
|
|
1065
|
+
return data;
|
|
1066
|
+
}
|
|
1067
|
+
};
|
|
1068
|
+
return mutationOptions;
|
|
1069
|
+
};
|
|
1070
|
+
var listSecretGrantsQueryKey = (options) => createQueryKey("listSecretGrants", options);
|
|
1071
|
+
var listSecretGrantsOptions = (options) => queryOptions({
|
|
1072
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1073
|
+
const { data } = await listSecretGrants({
|
|
1074
|
+
...options,
|
|
1075
|
+
...queryKey[0],
|
|
1076
|
+
signal,
|
|
1077
|
+
throwOnError: true
|
|
1078
|
+
});
|
|
1079
|
+
return data;
|
|
1080
|
+
},
|
|
1081
|
+
queryKey: listSecretGrantsQueryKey(options)
|
|
1082
|
+
});
|
|
1083
|
+
var listSecretGrantsInfiniteQueryKey = (options) => createQueryKey("listSecretGrants", options, true);
|
|
1084
|
+
var listSecretGrantsInfiniteOptions = (options) => {
|
|
1085
|
+
const opts = infiniteQueryOptions(
|
|
1086
|
+
// @ts-ignore
|
|
1087
|
+
{
|
|
1088
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1089
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1090
|
+
query: {
|
|
1091
|
+
cursor: pageParam
|
|
1092
|
+
}
|
|
1093
|
+
};
|
|
1094
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1095
|
+
const { data } = await listSecretGrants({
|
|
1096
|
+
...options,
|
|
1097
|
+
...params,
|
|
1098
|
+
signal,
|
|
1099
|
+
throwOnError: true
|
|
1100
|
+
});
|
|
1101
|
+
return data;
|
|
1102
|
+
},
|
|
1103
|
+
queryKey: listSecretGrantsInfiniteQueryKey(options)
|
|
1104
|
+
}
|
|
1105
|
+
);
|
|
1106
|
+
return opts;
|
|
1107
|
+
};
|
|
1108
|
+
var createSecretGrantMutation = (options) => {
|
|
1109
|
+
const mutationOptions = {
|
|
1110
|
+
mutationFn: async (fnOptions) => {
|
|
1111
|
+
const { data } = await createSecretGrant({
|
|
1112
|
+
...options,
|
|
1113
|
+
...fnOptions,
|
|
1114
|
+
throwOnError: true
|
|
1115
|
+
});
|
|
1116
|
+
return data;
|
|
1117
|
+
}
|
|
1118
|
+
};
|
|
1119
|
+
return mutationOptions;
|
|
1120
|
+
};
|
|
1121
|
+
var deleteSecretGrantMutation = (options) => {
|
|
1122
|
+
const mutationOptions = {
|
|
1123
|
+
mutationFn: async (fnOptions) => {
|
|
1124
|
+
const { data } = await deleteSecretGrant({
|
|
1125
|
+
...options,
|
|
1126
|
+
...fnOptions,
|
|
1127
|
+
throwOnError: true
|
|
1128
|
+
});
|
|
1129
|
+
return data;
|
|
1130
|
+
}
|
|
1131
|
+
};
|
|
1132
|
+
return mutationOptions;
|
|
1133
|
+
};
|
|
1134
|
+
var listIntegrationInstallsQueryKey = (options) => createQueryKey("listIntegrationInstalls", options);
|
|
1135
|
+
var listIntegrationInstallsOptions = (options) => queryOptions({
|
|
1136
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1137
|
+
const { data } = await listIntegrationInstalls({
|
|
1138
|
+
...options,
|
|
1139
|
+
...queryKey[0],
|
|
1140
|
+
signal,
|
|
1141
|
+
throwOnError: true
|
|
1142
|
+
});
|
|
1143
|
+
return data;
|
|
1144
|
+
},
|
|
1145
|
+
queryKey: listIntegrationInstallsQueryKey(options)
|
|
1146
|
+
});
|
|
1147
|
+
var listIntegrationInstallsInfiniteQueryKey = (options) => createQueryKey("listIntegrationInstalls", options, true);
|
|
1148
|
+
var listIntegrationInstallsInfiniteOptions = (options) => {
|
|
1149
|
+
const opts = infiniteQueryOptions(
|
|
1150
|
+
// @ts-ignore
|
|
1151
|
+
{
|
|
1152
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1153
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1154
|
+
query: {
|
|
1155
|
+
cursor: pageParam
|
|
1156
|
+
}
|
|
1157
|
+
};
|
|
1158
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1159
|
+
const { data } = await listIntegrationInstalls({
|
|
1160
|
+
...options,
|
|
1161
|
+
...params,
|
|
1162
|
+
signal,
|
|
1163
|
+
throwOnError: true
|
|
1164
|
+
});
|
|
1165
|
+
return data;
|
|
1166
|
+
},
|
|
1167
|
+
queryKey: listIntegrationInstallsInfiniteQueryKey(options)
|
|
1168
|
+
}
|
|
1169
|
+
);
|
|
1170
|
+
return opts;
|
|
1171
|
+
};
|
|
1172
|
+
var deleteIntegrationInstallMutation = (options) => {
|
|
1173
|
+
const mutationOptions = {
|
|
1174
|
+
mutationFn: async (fnOptions) => {
|
|
1175
|
+
const { data } = await deleteIntegrationInstall({
|
|
1176
|
+
...options,
|
|
1177
|
+
...fnOptions,
|
|
1178
|
+
throwOnError: true
|
|
1179
|
+
});
|
|
1180
|
+
return data;
|
|
1181
|
+
}
|
|
1182
|
+
};
|
|
1183
|
+
return mutationOptions;
|
|
1184
|
+
};
|
|
1185
|
+
var createAgentConfigMutation = (options) => {
|
|
1186
|
+
const mutationOptions = {
|
|
1187
|
+
mutationFn: async (fnOptions) => {
|
|
1188
|
+
const { data } = await createAgentConfig({
|
|
1189
|
+
...options,
|
|
1190
|
+
...fnOptions,
|
|
1191
|
+
throwOnError: true
|
|
1192
|
+
});
|
|
1193
|
+
return data;
|
|
1194
|
+
}
|
|
1195
|
+
};
|
|
1196
|
+
return mutationOptions;
|
|
1197
|
+
};
|
|
1198
|
+
var getToolCatalogQueryKey = (options) => createQueryKey("getToolCatalog", options);
|
|
1199
|
+
var getToolCatalogOptions = (options) => queryOptions({
|
|
1200
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1201
|
+
const { data } = await getToolCatalog({
|
|
1202
|
+
...options,
|
|
1203
|
+
...queryKey[0],
|
|
1204
|
+
signal,
|
|
1205
|
+
throwOnError: true
|
|
1206
|
+
});
|
|
1207
|
+
return data;
|
|
1208
|
+
},
|
|
1209
|
+
queryKey: getToolCatalogQueryKey(options)
|
|
1210
|
+
});
|
|
1211
|
+
var getAgentConfigQueryKey = (options) => createQueryKey("getAgentConfig", options);
|
|
1212
|
+
var getAgentConfigOptions = (options) => queryOptions({
|
|
1213
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1214
|
+
const { data } = await getAgentConfig({
|
|
1215
|
+
...options,
|
|
1216
|
+
...queryKey[0],
|
|
1217
|
+
signal,
|
|
1218
|
+
throwOnError: true
|
|
1219
|
+
});
|
|
1220
|
+
return data;
|
|
1221
|
+
},
|
|
1222
|
+
queryKey: getAgentConfigQueryKey(options)
|
|
1223
|
+
});
|
|
1224
|
+
var listAgentProfilesQueryKey = (options) => createQueryKey("listAgentProfiles", options);
|
|
1225
|
+
var listAgentProfilesOptions = (options) => queryOptions({
|
|
1226
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1227
|
+
const { data } = await listAgentProfiles({
|
|
1228
|
+
...options,
|
|
1229
|
+
...queryKey[0],
|
|
1230
|
+
signal,
|
|
1231
|
+
throwOnError: true
|
|
1232
|
+
});
|
|
1233
|
+
return data;
|
|
1234
|
+
},
|
|
1235
|
+
queryKey: listAgentProfilesQueryKey(options)
|
|
1236
|
+
});
|
|
1237
|
+
var listAgentProfilesInfiniteQueryKey = (options) => createQueryKey("listAgentProfiles", options, true);
|
|
1238
|
+
var listAgentProfilesInfiniteOptions = (options) => {
|
|
1239
|
+
const opts = infiniteQueryOptions(
|
|
1240
|
+
// @ts-ignore
|
|
1241
|
+
{
|
|
1242
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1243
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1244
|
+
query: {
|
|
1245
|
+
cursor: pageParam
|
|
1246
|
+
}
|
|
1247
|
+
};
|
|
1248
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1249
|
+
const { data } = await listAgentProfiles({
|
|
1250
|
+
...options,
|
|
1251
|
+
...params,
|
|
1252
|
+
signal,
|
|
1253
|
+
throwOnError: true
|
|
1254
|
+
});
|
|
1255
|
+
return data;
|
|
1256
|
+
},
|
|
1257
|
+
queryKey: listAgentProfilesInfiniteQueryKey(options)
|
|
1258
|
+
}
|
|
1259
|
+
);
|
|
1260
|
+
return opts;
|
|
1261
|
+
};
|
|
1262
|
+
var createAgentProfileMutation = (options) => {
|
|
1263
|
+
const mutationOptions = {
|
|
1264
|
+
mutationFn: async (fnOptions) => {
|
|
1265
|
+
const { data } = await createAgentProfile({
|
|
1266
|
+
...options,
|
|
1267
|
+
...fnOptions,
|
|
1268
|
+
throwOnError: true
|
|
1269
|
+
});
|
|
1270
|
+
return data;
|
|
1271
|
+
}
|
|
1272
|
+
};
|
|
1273
|
+
return mutationOptions;
|
|
1274
|
+
};
|
|
1275
|
+
var deleteAgentProfileMutation = (options) => {
|
|
1276
|
+
const mutationOptions = {
|
|
1277
|
+
mutationFn: async (fnOptions) => {
|
|
1278
|
+
const { data } = await deleteAgentProfile({
|
|
1279
|
+
...options,
|
|
1280
|
+
...fnOptions,
|
|
1281
|
+
throwOnError: true
|
|
1282
|
+
});
|
|
1283
|
+
return data;
|
|
1284
|
+
}
|
|
1285
|
+
};
|
|
1286
|
+
return mutationOptions;
|
|
1287
|
+
};
|
|
1288
|
+
var getAgentProfileQueryKey = (options) => createQueryKey("getAgentProfile", options);
|
|
1289
|
+
var getAgentProfileOptions = (options) => queryOptions({
|
|
1290
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1291
|
+
const { data } = await getAgentProfile({
|
|
1292
|
+
...options,
|
|
1293
|
+
...queryKey[0],
|
|
1294
|
+
signal,
|
|
1295
|
+
throwOnError: true
|
|
1296
|
+
});
|
|
1297
|
+
return data;
|
|
1298
|
+
},
|
|
1299
|
+
queryKey: getAgentProfileQueryKey(options)
|
|
1300
|
+
});
|
|
1301
|
+
var renameAgentProfileMutation = (options) => {
|
|
1302
|
+
const mutationOptions = {
|
|
1303
|
+
mutationFn: async (fnOptions) => {
|
|
1304
|
+
const { data } = await renameAgentProfile({
|
|
1305
|
+
...options,
|
|
1306
|
+
...fnOptions,
|
|
1307
|
+
throwOnError: true
|
|
1308
|
+
});
|
|
1309
|
+
return data;
|
|
1310
|
+
}
|
|
1311
|
+
};
|
|
1312
|
+
return mutationOptions;
|
|
1313
|
+
};
|
|
1314
|
+
var updateAgentProfileMutation = (options) => {
|
|
1315
|
+
const mutationOptions = {
|
|
1316
|
+
mutationFn: async (fnOptions) => {
|
|
1317
|
+
const { data } = await updateAgentProfile({
|
|
1318
|
+
...options,
|
|
1319
|
+
...fnOptions,
|
|
1320
|
+
throwOnError: true
|
|
1321
|
+
});
|
|
1322
|
+
return data;
|
|
1323
|
+
}
|
|
1324
|
+
};
|
|
1325
|
+
return mutationOptions;
|
|
1326
|
+
};
|
|
1327
|
+
var createIntegrationOAuthSetupMutation = (options) => {
|
|
1328
|
+
const mutationOptions = {
|
|
1329
|
+
mutationFn: async (fnOptions) => {
|
|
1330
|
+
const { data } = await createIntegrationOAuthSetup({
|
|
1331
|
+
...options,
|
|
1332
|
+
...fnOptions,
|
|
1333
|
+
throwOnError: true
|
|
1334
|
+
});
|
|
1335
|
+
return data;
|
|
1336
|
+
}
|
|
1337
|
+
};
|
|
1338
|
+
return mutationOptions;
|
|
1339
|
+
};
|
|
1340
|
+
var createSlackSetupMutation = (options) => {
|
|
1341
|
+
const mutationOptions = {
|
|
1342
|
+
mutationFn: async (fnOptions) => {
|
|
1343
|
+
const { data } = await createSlackSetup({
|
|
1344
|
+
...options,
|
|
1345
|
+
...fnOptions,
|
|
1346
|
+
throwOnError: true
|
|
1347
|
+
});
|
|
1348
|
+
return data;
|
|
1349
|
+
}
|
|
1350
|
+
};
|
|
1351
|
+
return mutationOptions;
|
|
1352
|
+
};
|
|
1353
|
+
var listCronTriggersQueryKey = (options) => createQueryKey("listCronTriggers", options);
|
|
1354
|
+
var listCronTriggersOptions = (options) => queryOptions({
|
|
1355
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1356
|
+
const { data } = await listCronTriggers({
|
|
1357
|
+
...options,
|
|
1358
|
+
...queryKey[0],
|
|
1359
|
+
signal,
|
|
1360
|
+
throwOnError: true
|
|
1361
|
+
});
|
|
1362
|
+
return data;
|
|
1363
|
+
},
|
|
1364
|
+
queryKey: listCronTriggersQueryKey(options)
|
|
1365
|
+
});
|
|
1366
|
+
var listCronTriggersInfiniteQueryKey = (options) => createQueryKey("listCronTriggers", options, true);
|
|
1367
|
+
var listCronTriggersInfiniteOptions = (options) => {
|
|
1368
|
+
const opts = infiniteQueryOptions(
|
|
1369
|
+
// @ts-ignore
|
|
1370
|
+
{
|
|
1371
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1372
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1373
|
+
query: {
|
|
1374
|
+
cursor: pageParam
|
|
1375
|
+
}
|
|
1376
|
+
};
|
|
1377
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1378
|
+
const { data } = await listCronTriggers({
|
|
1379
|
+
...options,
|
|
1380
|
+
...params,
|
|
1381
|
+
signal,
|
|
1382
|
+
throwOnError: true
|
|
1383
|
+
});
|
|
1384
|
+
return data;
|
|
1385
|
+
},
|
|
1386
|
+
queryKey: listCronTriggersInfiniteQueryKey(options)
|
|
1387
|
+
}
|
|
1388
|
+
);
|
|
1389
|
+
return opts;
|
|
1390
|
+
};
|
|
1391
|
+
var createCronTriggerMutation = (options) => {
|
|
1392
|
+
const mutationOptions = {
|
|
1393
|
+
mutationFn: async (fnOptions) => {
|
|
1394
|
+
const { data } = await createCronTrigger({
|
|
1395
|
+
...options,
|
|
1396
|
+
...fnOptions,
|
|
1397
|
+
throwOnError: true
|
|
1398
|
+
});
|
|
1399
|
+
return data;
|
|
1400
|
+
}
|
|
1401
|
+
};
|
|
1402
|
+
return mutationOptions;
|
|
1403
|
+
};
|
|
1404
|
+
var deleteCronTriggerMutation = (options) => {
|
|
1405
|
+
const mutationOptions = {
|
|
1406
|
+
mutationFn: async (fnOptions) => {
|
|
1407
|
+
const { data } = await deleteCronTrigger({
|
|
1408
|
+
...options,
|
|
1409
|
+
...fnOptions,
|
|
1410
|
+
throwOnError: true
|
|
1411
|
+
});
|
|
1412
|
+
return data;
|
|
1413
|
+
}
|
|
1414
|
+
};
|
|
1415
|
+
return mutationOptions;
|
|
1416
|
+
};
|
|
1417
|
+
var getCronTriggerQueryKey = (options) => createQueryKey("getCronTrigger", options);
|
|
1418
|
+
var getCronTriggerOptions = (options) => queryOptions({
|
|
1419
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1420
|
+
const { data } = await getCronTrigger({
|
|
1421
|
+
...options,
|
|
1422
|
+
...queryKey[0],
|
|
1423
|
+
signal,
|
|
1424
|
+
throwOnError: true
|
|
1425
|
+
});
|
|
1426
|
+
return data;
|
|
1427
|
+
},
|
|
1428
|
+
queryKey: getCronTriggerQueryKey(options)
|
|
1429
|
+
});
|
|
1430
|
+
var updateCronTriggerMutation = (options) => {
|
|
1431
|
+
const mutationOptions = {
|
|
1432
|
+
mutationFn: async (fnOptions) => {
|
|
1433
|
+
const { data } = await updateCronTrigger({
|
|
1434
|
+
...options,
|
|
1435
|
+
...fnOptions,
|
|
1436
|
+
throwOnError: true
|
|
1437
|
+
});
|
|
1438
|
+
return data;
|
|
1439
|
+
}
|
|
1440
|
+
};
|
|
1441
|
+
return mutationOptions;
|
|
1442
|
+
};
|
|
1443
|
+
var listAgentsQueryKey = (options) => createQueryKey("listAgents", options);
|
|
1444
|
+
var listAgentsOptions = (options) => queryOptions({
|
|
1445
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1446
|
+
const { data } = await listAgents({
|
|
1447
|
+
...options,
|
|
1448
|
+
...queryKey[0],
|
|
1449
|
+
signal,
|
|
1450
|
+
throwOnError: true
|
|
1451
|
+
});
|
|
1452
|
+
return data;
|
|
1453
|
+
},
|
|
1454
|
+
queryKey: listAgentsQueryKey(options)
|
|
1455
|
+
});
|
|
1456
|
+
var listAgentsInfiniteQueryKey = (options) => createQueryKey("listAgents", options, true);
|
|
1457
|
+
var listAgentsInfiniteOptions = (options) => {
|
|
1458
|
+
const opts = infiniteQueryOptions(
|
|
1459
|
+
// @ts-ignore
|
|
1460
|
+
{
|
|
1461
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1462
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1463
|
+
query: {
|
|
1464
|
+
cursor: pageParam
|
|
1465
|
+
}
|
|
1466
|
+
};
|
|
1467
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1468
|
+
const { data } = await listAgents({
|
|
1469
|
+
...options,
|
|
1470
|
+
...params,
|
|
1471
|
+
signal,
|
|
1472
|
+
throwOnError: true
|
|
1473
|
+
});
|
|
1474
|
+
return data;
|
|
1475
|
+
},
|
|
1476
|
+
queryKey: listAgentsInfiniteQueryKey(options)
|
|
1477
|
+
}
|
|
1478
|
+
);
|
|
1479
|
+
return opts;
|
|
1480
|
+
};
|
|
1481
|
+
var createAgentMutation = (options) => {
|
|
1482
|
+
const mutationOptions = {
|
|
1483
|
+
mutationFn: async (fnOptions) => {
|
|
1484
|
+
const { data } = await createAgent({
|
|
1485
|
+
...options,
|
|
1486
|
+
...fnOptions,
|
|
1487
|
+
throwOnError: true
|
|
1488
|
+
});
|
|
1489
|
+
return data;
|
|
1490
|
+
}
|
|
1491
|
+
};
|
|
1492
|
+
return mutationOptions;
|
|
1493
|
+
};
|
|
1494
|
+
var getAgentQueryKey = (options) => createQueryKey("getAgent", options);
|
|
1495
|
+
var getAgentOptions = (options) => queryOptions({
|
|
1496
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1497
|
+
const { data } = await getAgent({
|
|
1498
|
+
...options,
|
|
1499
|
+
...queryKey[0],
|
|
1500
|
+
signal,
|
|
1501
|
+
throwOnError: true
|
|
1502
|
+
});
|
|
1503
|
+
return data;
|
|
1504
|
+
},
|
|
1505
|
+
queryKey: getAgentQueryKey(options)
|
|
1506
|
+
});
|
|
1507
|
+
var archiveAgentMutation = (options) => {
|
|
1508
|
+
const mutationOptions = {
|
|
1509
|
+
mutationFn: async (fnOptions) => {
|
|
1510
|
+
const { data } = await archiveAgent({
|
|
1511
|
+
...options,
|
|
1512
|
+
...fnOptions,
|
|
1513
|
+
throwOnError: true
|
|
1514
|
+
});
|
|
1515
|
+
return data;
|
|
1516
|
+
}
|
|
1517
|
+
};
|
|
1518
|
+
return mutationOptions;
|
|
1519
|
+
};
|
|
1520
|
+
var updateAgentConfigMutation = (options) => {
|
|
1521
|
+
const mutationOptions = {
|
|
1522
|
+
mutationFn: async (fnOptions) => {
|
|
1523
|
+
const { data } = await updateAgentConfig({
|
|
1524
|
+
...options,
|
|
1525
|
+
...fnOptions,
|
|
1526
|
+
throwOnError: true
|
|
1527
|
+
});
|
|
1528
|
+
return data;
|
|
1529
|
+
}
|
|
1530
|
+
};
|
|
1531
|
+
return mutationOptions;
|
|
1532
|
+
};
|
|
1533
|
+
var createAgentInputMutation = (options) => {
|
|
1534
|
+
const mutationOptions = {
|
|
1535
|
+
mutationFn: async (fnOptions) => {
|
|
1536
|
+
const { data } = await createAgentInput({
|
|
1537
|
+
...options,
|
|
1538
|
+
...fnOptions,
|
|
1539
|
+
throwOnError: true
|
|
1540
|
+
});
|
|
1541
|
+
return data;
|
|
1542
|
+
}
|
|
1543
|
+
};
|
|
1544
|
+
return mutationOptions;
|
|
1545
|
+
};
|
|
1546
|
+
var listToolCallsQueryKey = (options) => createQueryKey("listToolCalls", options);
|
|
1547
|
+
var listToolCallsOptions = (options) => queryOptions({
|
|
1548
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1549
|
+
const { data } = await listToolCalls({
|
|
1550
|
+
...options,
|
|
1551
|
+
...queryKey[0],
|
|
1552
|
+
signal,
|
|
1553
|
+
throwOnError: true
|
|
1554
|
+
});
|
|
1555
|
+
return data;
|
|
1556
|
+
},
|
|
1557
|
+
queryKey: listToolCallsQueryKey(options)
|
|
1558
|
+
});
|
|
1559
|
+
var listToolCallsInfiniteQueryKey = (options) => createQueryKey("listToolCalls", options, true);
|
|
1560
|
+
var listToolCallsInfiniteOptions = (options) => {
|
|
1561
|
+
const opts = infiniteQueryOptions(
|
|
1562
|
+
// @ts-ignore
|
|
1563
|
+
{
|
|
1564
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1565
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1566
|
+
query: {
|
|
1567
|
+
cursor: pageParam
|
|
1568
|
+
}
|
|
1569
|
+
};
|
|
1570
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1571
|
+
const { data } = await listToolCalls({
|
|
1572
|
+
...options,
|
|
1573
|
+
...params,
|
|
1574
|
+
signal,
|
|
1575
|
+
throwOnError: true
|
|
1576
|
+
});
|
|
1577
|
+
return data;
|
|
1578
|
+
},
|
|
1579
|
+
queryKey: listToolCallsInfiniteQueryKey(options)
|
|
1580
|
+
}
|
|
1581
|
+
);
|
|
1582
|
+
return opts;
|
|
1583
|
+
};
|
|
1584
|
+
var submitToolCallResultMutation = (options) => {
|
|
1585
|
+
const mutationOptions = {
|
|
1586
|
+
mutationFn: async (fnOptions) => {
|
|
1587
|
+
const { data } = await submitToolCallResult({
|
|
1588
|
+
...options,
|
|
1589
|
+
...fnOptions,
|
|
1590
|
+
throwOnError: true
|
|
1591
|
+
});
|
|
1592
|
+
return data;
|
|
1593
|
+
}
|
|
1594
|
+
};
|
|
1595
|
+
return mutationOptions;
|
|
1596
|
+
};
|
|
1597
|
+
var listTurnsQueryKey = (options) => createQueryKey("listTurns", options);
|
|
1598
|
+
var listTurnsOptions = (options) => queryOptions({
|
|
1599
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1600
|
+
const { data } = await listTurns({
|
|
1601
|
+
...options,
|
|
1602
|
+
...queryKey[0],
|
|
1603
|
+
signal,
|
|
1604
|
+
throwOnError: true
|
|
1605
|
+
});
|
|
1606
|
+
return data;
|
|
1607
|
+
},
|
|
1608
|
+
queryKey: listTurnsQueryKey(options)
|
|
1609
|
+
});
|
|
1610
|
+
var listTurnEventsQueryKey = (options) => createQueryKey("listTurnEvents", options);
|
|
1611
|
+
var listTurnEventsOptions = (options) => queryOptions({
|
|
1612
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1613
|
+
const { data } = await listTurnEvents({
|
|
1614
|
+
...options,
|
|
1615
|
+
...queryKey[0],
|
|
1616
|
+
signal,
|
|
1617
|
+
throwOnError: true
|
|
1618
|
+
});
|
|
1619
|
+
return data;
|
|
1620
|
+
},
|
|
1621
|
+
queryKey: listTurnEventsQueryKey(options)
|
|
1622
|
+
});
|
|
1623
|
+
var listEventsQueryKey = (options) => createQueryKey("listEvents", options);
|
|
1624
|
+
var listEventsOptions = (options) => queryOptions({
|
|
1625
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1626
|
+
const { data } = await listEvents({
|
|
1627
|
+
...options,
|
|
1628
|
+
...queryKey[0],
|
|
1629
|
+
signal,
|
|
1630
|
+
throwOnError: true
|
|
1631
|
+
});
|
|
1632
|
+
return data;
|
|
1633
|
+
},
|
|
1634
|
+
queryKey: listEventsQueryKey(options)
|
|
1635
|
+
});
|
|
1636
|
+
var cancelAgentMutation = (options) => {
|
|
1637
|
+
const mutationOptions = {
|
|
1638
|
+
mutationFn: async (fnOptions) => {
|
|
1639
|
+
const { data } = await cancelAgent({
|
|
1640
|
+
...options,
|
|
1641
|
+
...fnOptions,
|
|
1642
|
+
throwOnError: true
|
|
1643
|
+
});
|
|
1644
|
+
return data;
|
|
1645
|
+
}
|
|
1646
|
+
};
|
|
1647
|
+
return mutationOptions;
|
|
1648
|
+
};
|
|
1649
|
+
var listAgentInteractionsQueryKey = (options) => createQueryKey("listAgentInteractions", options);
|
|
1650
|
+
var listAgentInteractionsOptions = (options) => queryOptions({
|
|
1651
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1652
|
+
const { data } = await listAgentInteractions({
|
|
1653
|
+
...options,
|
|
1654
|
+
...queryKey[0],
|
|
1655
|
+
signal,
|
|
1656
|
+
throwOnError: true
|
|
1657
|
+
});
|
|
1658
|
+
return data;
|
|
1659
|
+
},
|
|
1660
|
+
queryKey: listAgentInteractionsQueryKey(options)
|
|
1661
|
+
});
|
|
1662
|
+
var listAgentInteractionsInfiniteQueryKey = (options) => createQueryKey("listAgentInteractions", options, true);
|
|
1663
|
+
var listAgentInteractionsInfiniteOptions = (options) => {
|
|
1664
|
+
const opts = infiniteQueryOptions(
|
|
1665
|
+
// @ts-ignore
|
|
1666
|
+
{
|
|
1667
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1668
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1669
|
+
query: {
|
|
1670
|
+
cursor: pageParam
|
|
1671
|
+
}
|
|
1672
|
+
};
|
|
1673
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1674
|
+
const { data } = await listAgentInteractions({
|
|
1675
|
+
...options,
|
|
1676
|
+
...params,
|
|
1677
|
+
signal,
|
|
1678
|
+
throwOnError: true
|
|
1679
|
+
});
|
|
1680
|
+
return data;
|
|
1681
|
+
},
|
|
1682
|
+
queryKey: listAgentInteractionsInfiniteQueryKey(options)
|
|
1683
|
+
}
|
|
1684
|
+
);
|
|
1685
|
+
return opts;
|
|
1686
|
+
};
|
|
1687
|
+
var resolveAgentInteractionMutation = (options) => {
|
|
1688
|
+
const mutationOptions = {
|
|
1689
|
+
mutationFn: async (fnOptions) => {
|
|
1690
|
+
const { data } = await resolveAgentInteraction({
|
|
1691
|
+
...options,
|
|
1692
|
+
...fnOptions,
|
|
1693
|
+
throwOnError: true
|
|
1694
|
+
});
|
|
1695
|
+
return data;
|
|
1696
|
+
}
|
|
1697
|
+
};
|
|
1698
|
+
return mutationOptions;
|
|
1699
|
+
};
|
|
1700
|
+
var listQueuedBacklogInputsQueryKey = (options) => createQueryKey("listQueuedBacklogInputs", options);
|
|
1701
|
+
var listQueuedBacklogInputsOptions = (options) => queryOptions({
|
|
1702
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1703
|
+
const { data } = await listQueuedBacklogInputs({
|
|
1704
|
+
...options,
|
|
1705
|
+
...queryKey[0],
|
|
1706
|
+
signal,
|
|
1707
|
+
throwOnError: true
|
|
1708
|
+
});
|
|
1709
|
+
return data;
|
|
1710
|
+
},
|
|
1711
|
+
queryKey: listQueuedBacklogInputsQueryKey(options)
|
|
1712
|
+
});
|
|
1713
|
+
var listQueuedBacklogInputsInfiniteQueryKey = (options) => createQueryKey("listQueuedBacklogInputs", options, true);
|
|
1714
|
+
var listQueuedBacklogInputsInfiniteOptions = (options) => {
|
|
1715
|
+
const opts = infiniteQueryOptions(
|
|
1716
|
+
// @ts-ignore
|
|
1717
|
+
{
|
|
1718
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1719
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1720
|
+
query: {
|
|
1721
|
+
cursor: pageParam
|
|
1722
|
+
}
|
|
1723
|
+
};
|
|
1724
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1725
|
+
const { data } = await listQueuedBacklogInputs({
|
|
1726
|
+
...options,
|
|
1727
|
+
...params,
|
|
1728
|
+
signal,
|
|
1729
|
+
throwOnError: true
|
|
1730
|
+
});
|
|
1731
|
+
return data;
|
|
1732
|
+
},
|
|
1733
|
+
queryKey: listQueuedBacklogInputsInfiniteQueryKey(options)
|
|
1734
|
+
}
|
|
1735
|
+
);
|
|
1736
|
+
return opts;
|
|
1737
|
+
};
|
|
1738
|
+
var cancelQueuedBacklogInputMutation = (options) => {
|
|
1739
|
+
const mutationOptions = {
|
|
1740
|
+
mutationFn: async (fnOptions) => {
|
|
1741
|
+
const { data } = await cancelQueuedBacklogInput({
|
|
1742
|
+
...options,
|
|
1743
|
+
...fnOptions,
|
|
1744
|
+
throwOnError: true
|
|
1745
|
+
});
|
|
1746
|
+
return data;
|
|
1747
|
+
}
|
|
1748
|
+
};
|
|
1749
|
+
return mutationOptions;
|
|
1750
|
+
};
|
|
1751
|
+
var moveQueuedBacklogInputMutation = (options) => {
|
|
1752
|
+
const mutationOptions = {
|
|
1753
|
+
mutationFn: async (fnOptions) => {
|
|
1754
|
+
const { data } = await moveQueuedBacklogInput({
|
|
1755
|
+
...options,
|
|
1756
|
+
...fnOptions,
|
|
1757
|
+
throwOnError: true
|
|
1758
|
+
});
|
|
1759
|
+
return data;
|
|
1760
|
+
}
|
|
1761
|
+
};
|
|
1762
|
+
return mutationOptions;
|
|
1763
|
+
};
|
|
1764
|
+
var promoteQueuedInputToSteeringMutation = (options) => {
|
|
1765
|
+
const mutationOptions = {
|
|
1766
|
+
mutationFn: async (fnOptions) => {
|
|
1767
|
+
const { data } = await promoteQueuedInputToSteering({
|
|
1768
|
+
...options,
|
|
1769
|
+
...fnOptions,
|
|
1770
|
+
throwOnError: true
|
|
1771
|
+
});
|
|
1772
|
+
return data;
|
|
1773
|
+
}
|
|
1774
|
+
};
|
|
1775
|
+
return mutationOptions;
|
|
1776
|
+
};
|
|
1777
|
+
var demoteSteeringInputToQueuedMutation = (options) => {
|
|
1778
|
+
const mutationOptions = {
|
|
1779
|
+
mutationFn: async (fnOptions) => {
|
|
1780
|
+
const { data } = await demoteSteeringInputToQueued({
|
|
1781
|
+
...options,
|
|
1782
|
+
...fnOptions,
|
|
1783
|
+
throwOnError: true
|
|
1784
|
+
});
|
|
1785
|
+
return data;
|
|
1786
|
+
}
|
|
1787
|
+
};
|
|
1788
|
+
return mutationOptions;
|
|
1789
|
+
};
|
|
1790
|
+
var getArtifactQueryKey = (options) => createQueryKey("getArtifact", options);
|
|
1791
|
+
var getArtifactOptions = (options) => queryOptions({
|
|
1792
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1793
|
+
const { data } = await getArtifact({
|
|
1794
|
+
...options,
|
|
1795
|
+
...queryKey[0],
|
|
1796
|
+
signal,
|
|
1797
|
+
throwOnError: true
|
|
1798
|
+
});
|
|
1799
|
+
return data;
|
|
1800
|
+
},
|
|
1801
|
+
queryKey: getArtifactQueryKey(options)
|
|
1802
|
+
});
|
|
1803
|
+
var getArtifactContentQueryKey = (options) => createQueryKey("getArtifactContent", options);
|
|
1804
|
+
var getArtifactContentOptions = (options) => queryOptions({
|
|
1805
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1806
|
+
const { data } = await getArtifactContent({
|
|
1807
|
+
...options,
|
|
1808
|
+
...queryKey[0],
|
|
1809
|
+
signal,
|
|
1810
|
+
throwOnError: true
|
|
1811
|
+
});
|
|
1812
|
+
return data;
|
|
1813
|
+
},
|
|
1814
|
+
queryKey: getArtifactContentQueryKey(options)
|
|
1815
|
+
});
|
|
1816
|
+
var listVisibleProjectMachinesQueryKey = (options) => createQueryKey("listVisibleProjectMachines", options);
|
|
1817
|
+
var listVisibleProjectMachinesOptions = (options) => queryOptions({
|
|
1818
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1819
|
+
const { data } = await listVisibleProjectMachines({
|
|
1820
|
+
...options,
|
|
1821
|
+
...queryKey[0],
|
|
1822
|
+
signal,
|
|
1823
|
+
throwOnError: true
|
|
1824
|
+
});
|
|
1825
|
+
return data;
|
|
1826
|
+
},
|
|
1827
|
+
queryKey: listVisibleProjectMachinesQueryKey(options)
|
|
1828
|
+
});
|
|
1829
|
+
var listVisibleProjectMachinesInfiniteQueryKey = (options) => createQueryKey("listVisibleProjectMachines", options, true);
|
|
1830
|
+
var listVisibleProjectMachinesInfiniteOptions = (options) => {
|
|
1831
|
+
const opts = infiniteQueryOptions(
|
|
1832
|
+
// @ts-ignore
|
|
1833
|
+
{
|
|
1834
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1835
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1836
|
+
query: {
|
|
1837
|
+
cursor: pageParam
|
|
1838
|
+
}
|
|
1839
|
+
};
|
|
1840
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1841
|
+
const { data } = await listVisibleProjectMachines({
|
|
1842
|
+
...options,
|
|
1843
|
+
...params,
|
|
1844
|
+
signal,
|
|
1845
|
+
throwOnError: true
|
|
1846
|
+
});
|
|
1847
|
+
return data;
|
|
1848
|
+
},
|
|
1849
|
+
queryKey: listVisibleProjectMachinesInfiniteQueryKey(options)
|
|
1850
|
+
}
|
|
1851
|
+
);
|
|
1852
|
+
return opts;
|
|
1853
|
+
};
|
|
1854
|
+
var listProjectMachineGrantsQueryKey = (options) => createQueryKey("listProjectMachineGrants", options);
|
|
1855
|
+
var listProjectMachineGrantsOptions = (options) => queryOptions({
|
|
1856
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1857
|
+
const { data } = await listProjectMachineGrants({
|
|
1858
|
+
...options,
|
|
1859
|
+
...queryKey[0],
|
|
1860
|
+
signal,
|
|
1861
|
+
throwOnError: true
|
|
1862
|
+
});
|
|
1863
|
+
return data;
|
|
1864
|
+
},
|
|
1865
|
+
queryKey: listProjectMachineGrantsQueryKey(options)
|
|
1866
|
+
});
|
|
1867
|
+
var listProjectMachineGrantsInfiniteQueryKey = (options) => createQueryKey("listProjectMachineGrants", options, true);
|
|
1868
|
+
var listProjectMachineGrantsInfiniteOptions = (options) => {
|
|
1869
|
+
const opts = infiniteQueryOptions(
|
|
1870
|
+
// @ts-ignore
|
|
1871
|
+
{
|
|
1872
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1873
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1874
|
+
query: {
|
|
1875
|
+
cursor: pageParam
|
|
1876
|
+
}
|
|
1877
|
+
};
|
|
1878
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1879
|
+
const { data } = await listProjectMachineGrants({
|
|
1880
|
+
...options,
|
|
1881
|
+
...params,
|
|
1882
|
+
signal,
|
|
1883
|
+
throwOnError: true
|
|
1884
|
+
});
|
|
1885
|
+
return data;
|
|
1886
|
+
},
|
|
1887
|
+
queryKey: listProjectMachineGrantsInfiniteQueryKey(options)
|
|
1888
|
+
}
|
|
1889
|
+
);
|
|
1890
|
+
return opts;
|
|
1891
|
+
};
|
|
1892
|
+
var createProjectMachineGrantMutation = (options) => {
|
|
1893
|
+
const mutationOptions = {
|
|
1894
|
+
mutationFn: async (fnOptions) => {
|
|
1895
|
+
const { data } = await createProjectMachineGrant({
|
|
1896
|
+
...options,
|
|
1897
|
+
...fnOptions,
|
|
1898
|
+
throwOnError: true
|
|
1899
|
+
});
|
|
1900
|
+
return data;
|
|
1901
|
+
}
|
|
1902
|
+
};
|
|
1903
|
+
return mutationOptions;
|
|
1904
|
+
};
|
|
1905
|
+
var deleteProjectMachineGrantMutation = (options) => {
|
|
1906
|
+
const mutationOptions = {
|
|
1907
|
+
mutationFn: async (fnOptions) => {
|
|
1908
|
+
const { data } = await deleteProjectMachineGrant({
|
|
1909
|
+
...options,
|
|
1910
|
+
...fnOptions,
|
|
1911
|
+
throwOnError: true
|
|
1912
|
+
});
|
|
1913
|
+
return data;
|
|
1914
|
+
}
|
|
1915
|
+
};
|
|
1916
|
+
return mutationOptions;
|
|
1917
|
+
};
|
|
1918
|
+
var listProjectAvailableSecretsQueryKey = (options) => createQueryKey("listProjectAvailableSecrets", options);
|
|
1919
|
+
var listProjectAvailableSecretsOptions = (options) => queryOptions({
|
|
1920
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1921
|
+
const { data } = await listProjectAvailableSecrets({
|
|
1922
|
+
...options,
|
|
1923
|
+
...queryKey[0],
|
|
1924
|
+
signal,
|
|
1925
|
+
throwOnError: true
|
|
1926
|
+
});
|
|
1927
|
+
return data;
|
|
1928
|
+
},
|
|
1929
|
+
queryKey: listProjectAvailableSecretsQueryKey(options)
|
|
1930
|
+
});
|
|
1931
|
+
var listProjectAvailableSecretsInfiniteQueryKey = (options) => createQueryKey("listProjectAvailableSecrets", options, true);
|
|
1932
|
+
var listProjectAvailableSecretsInfiniteOptions = (options) => {
|
|
1933
|
+
const opts = infiniteQueryOptions(
|
|
1934
|
+
// @ts-ignore
|
|
1935
|
+
{
|
|
1936
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1937
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1938
|
+
query: {
|
|
1939
|
+
cursor: pageParam
|
|
1940
|
+
}
|
|
1941
|
+
};
|
|
1942
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1943
|
+
const { data } = await listProjectAvailableSecrets({
|
|
1944
|
+
...options,
|
|
1945
|
+
...params,
|
|
1946
|
+
signal,
|
|
1947
|
+
throwOnError: true
|
|
1948
|
+
});
|
|
1949
|
+
return data;
|
|
1950
|
+
},
|
|
1951
|
+
queryKey: listProjectAvailableSecretsInfiniteQueryKey(options)
|
|
1952
|
+
}
|
|
1953
|
+
);
|
|
1954
|
+
return opts;
|
|
1955
|
+
};
|
|
1956
|
+
var getProjectAvailableSecretQueryKey = (options) => createQueryKey("getProjectAvailableSecret", options);
|
|
1957
|
+
var getProjectAvailableSecretOptions = (options) => queryOptions({
|
|
1958
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1959
|
+
const { data } = await getProjectAvailableSecret({
|
|
1960
|
+
...options,
|
|
1961
|
+
...queryKey[0],
|
|
1962
|
+
signal,
|
|
1963
|
+
throwOnError: true
|
|
1964
|
+
});
|
|
1965
|
+
return data;
|
|
1966
|
+
},
|
|
1967
|
+
queryKey: getProjectAvailableSecretQueryKey(options)
|
|
1968
|
+
});
|
|
1969
|
+
var listActorsQueryKey = (options) => createQueryKey("listActors", options);
|
|
1970
|
+
var listActorsOptions = (options) => queryOptions({
|
|
1971
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
1972
|
+
const { data } = await listActors({
|
|
1973
|
+
...options,
|
|
1974
|
+
...queryKey[0],
|
|
1975
|
+
signal,
|
|
1976
|
+
throwOnError: true
|
|
1977
|
+
});
|
|
1978
|
+
return data;
|
|
1979
|
+
},
|
|
1980
|
+
queryKey: listActorsQueryKey(options)
|
|
1981
|
+
});
|
|
1982
|
+
var listActorsInfiniteQueryKey = (options) => createQueryKey("listActors", options, true);
|
|
1983
|
+
var listActorsInfiniteOptions = (options) => {
|
|
1984
|
+
const opts = infiniteQueryOptions(
|
|
1985
|
+
// @ts-ignore
|
|
1986
|
+
{
|
|
1987
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
1988
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
1989
|
+
query: {
|
|
1990
|
+
cursor: pageParam
|
|
1991
|
+
}
|
|
1992
|
+
};
|
|
1993
|
+
const params = createInfiniteParams(queryKey, page);
|
|
1994
|
+
const { data } = await listActors({
|
|
1995
|
+
...options,
|
|
1996
|
+
...params,
|
|
1997
|
+
signal,
|
|
1998
|
+
throwOnError: true
|
|
1999
|
+
});
|
|
2000
|
+
return data;
|
|
2001
|
+
},
|
|
2002
|
+
queryKey: listActorsInfiniteQueryKey(options)
|
|
2003
|
+
}
|
|
2004
|
+
);
|
|
2005
|
+
return opts;
|
|
2006
|
+
};
|
|
2007
|
+
var putActorMutation = (options) => {
|
|
2008
|
+
const mutationOptions = {
|
|
2009
|
+
mutationFn: async (fnOptions) => {
|
|
2010
|
+
const { data } = await putActor({
|
|
2011
|
+
...options,
|
|
2012
|
+
...fnOptions,
|
|
2013
|
+
throwOnError: true
|
|
2014
|
+
});
|
|
2015
|
+
return data;
|
|
2016
|
+
}
|
|
2017
|
+
};
|
|
2018
|
+
return mutationOptions;
|
|
2019
|
+
};
|
|
2020
|
+
var getActorQueryKey = (options) => createQueryKey("getActor", options);
|
|
2021
|
+
var getActorOptions = (options) => queryOptions({
|
|
2022
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2023
|
+
const { data } = await getActor({
|
|
2024
|
+
...options,
|
|
2025
|
+
...queryKey[0],
|
|
2026
|
+
signal,
|
|
2027
|
+
throwOnError: true
|
|
2028
|
+
});
|
|
2029
|
+
return data;
|
|
2030
|
+
},
|
|
2031
|
+
queryKey: getActorQueryKey(options)
|
|
2032
|
+
});
|
|
2033
|
+
var listVisibleMachinesQueryKey = (options) => createQueryKey("listVisibleMachines", options);
|
|
2034
|
+
var listVisibleMachinesOptions = (options) => queryOptions({
|
|
2035
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2036
|
+
const { data } = await listVisibleMachines({
|
|
2037
|
+
...options,
|
|
2038
|
+
...queryKey[0],
|
|
2039
|
+
signal,
|
|
2040
|
+
throwOnError: true
|
|
2041
|
+
});
|
|
2042
|
+
return data;
|
|
2043
|
+
},
|
|
2044
|
+
queryKey: listVisibleMachinesQueryKey(options)
|
|
2045
|
+
});
|
|
2046
|
+
var listVisibleMachinesInfiniteQueryKey = (options) => createQueryKey("listVisibleMachines", options, true);
|
|
2047
|
+
var listVisibleMachinesInfiniteOptions = (options) => {
|
|
2048
|
+
const opts = infiniteQueryOptions(
|
|
2049
|
+
// @ts-ignore
|
|
2050
|
+
{
|
|
2051
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
2052
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
2053
|
+
query: {
|
|
2054
|
+
cursor: pageParam
|
|
2055
|
+
}
|
|
2056
|
+
};
|
|
2057
|
+
const params = createInfiniteParams(queryKey, page);
|
|
2058
|
+
const { data } = await listVisibleMachines({
|
|
2059
|
+
...options,
|
|
2060
|
+
...params,
|
|
2061
|
+
signal,
|
|
2062
|
+
throwOnError: true
|
|
2063
|
+
});
|
|
2064
|
+
return data;
|
|
2065
|
+
},
|
|
2066
|
+
queryKey: listVisibleMachinesInfiniteQueryKey(options)
|
|
2067
|
+
}
|
|
2068
|
+
);
|
|
2069
|
+
return opts;
|
|
2070
|
+
};
|
|
2071
|
+
var createMachineMutation = (options) => {
|
|
2072
|
+
const mutationOptions = {
|
|
2073
|
+
mutationFn: async (fnOptions) => {
|
|
2074
|
+
const { data } = await createMachine({
|
|
2075
|
+
...options,
|
|
2076
|
+
...fnOptions,
|
|
2077
|
+
throwOnError: true
|
|
2078
|
+
});
|
|
2079
|
+
return data;
|
|
2080
|
+
}
|
|
2081
|
+
};
|
|
2082
|
+
return mutationOptions;
|
|
2083
|
+
};
|
|
2084
|
+
var connectByoMachineMutation = (options) => {
|
|
2085
|
+
const mutationOptions = {
|
|
2086
|
+
mutationFn: async (fnOptions) => {
|
|
2087
|
+
const { data } = await connectByoMachine({
|
|
2088
|
+
...options,
|
|
2089
|
+
...fnOptions,
|
|
2090
|
+
throwOnError: true
|
|
2091
|
+
});
|
|
2092
|
+
return data;
|
|
2093
|
+
}
|
|
2094
|
+
};
|
|
2095
|
+
return mutationOptions;
|
|
2096
|
+
};
|
|
2097
|
+
var deleteMachineMutation = (options) => {
|
|
2098
|
+
const mutationOptions = {
|
|
2099
|
+
mutationFn: async (fnOptions) => {
|
|
2100
|
+
const { data } = await deleteMachine({
|
|
2101
|
+
...options,
|
|
2102
|
+
...fnOptions,
|
|
2103
|
+
throwOnError: true
|
|
2104
|
+
});
|
|
2105
|
+
return data;
|
|
2106
|
+
}
|
|
2107
|
+
};
|
|
2108
|
+
return mutationOptions;
|
|
2109
|
+
};
|
|
2110
|
+
var getMachineQueryKey = (options) => createQueryKey("getMachine", options);
|
|
2111
|
+
var getMachineOptions = (options) => queryOptions({
|
|
2112
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2113
|
+
const { data } = await getMachine({
|
|
2114
|
+
...options,
|
|
2115
|
+
...queryKey[0],
|
|
2116
|
+
signal,
|
|
2117
|
+
throwOnError: true
|
|
2118
|
+
});
|
|
2119
|
+
return data;
|
|
2120
|
+
},
|
|
2121
|
+
queryKey: getMachineQueryKey(options)
|
|
2122
|
+
});
|
|
2123
|
+
var updateMachineMutation = (options) => {
|
|
2124
|
+
const mutationOptions = {
|
|
2125
|
+
mutationFn: async (fnOptions) => {
|
|
2126
|
+
const { data } = await updateMachine({
|
|
2127
|
+
...options,
|
|
2128
|
+
...fnOptions,
|
|
2129
|
+
throwOnError: true
|
|
2130
|
+
});
|
|
2131
|
+
return data;
|
|
2132
|
+
}
|
|
2133
|
+
};
|
|
2134
|
+
return mutationOptions;
|
|
2135
|
+
};
|
|
2136
|
+
var listModelProviderConfigsQueryKey = (options) => createQueryKey("listModelProviderConfigs", options);
|
|
2137
|
+
var listModelProviderConfigsOptions = (options) => queryOptions({
|
|
2138
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2139
|
+
const { data } = await listModelProviderConfigs({
|
|
2140
|
+
...options,
|
|
2141
|
+
...queryKey[0],
|
|
2142
|
+
signal,
|
|
2143
|
+
throwOnError: true
|
|
2144
|
+
});
|
|
2145
|
+
return data;
|
|
2146
|
+
},
|
|
2147
|
+
queryKey: listModelProviderConfigsQueryKey(options)
|
|
2148
|
+
});
|
|
2149
|
+
var listModelProviderConfigsInfiniteQueryKey = (options) => createQueryKey("listModelProviderConfigs", options, true);
|
|
2150
|
+
var listModelProviderConfigsInfiniteOptions = (options) => {
|
|
2151
|
+
const opts = infiniteQueryOptions(
|
|
2152
|
+
// @ts-ignore
|
|
2153
|
+
{
|
|
2154
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
2155
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
2156
|
+
query: {
|
|
2157
|
+
cursor: pageParam
|
|
2158
|
+
}
|
|
2159
|
+
};
|
|
2160
|
+
const params = createInfiniteParams(queryKey, page);
|
|
2161
|
+
const { data } = await listModelProviderConfigs({
|
|
2162
|
+
...options,
|
|
2163
|
+
...params,
|
|
2164
|
+
signal,
|
|
2165
|
+
throwOnError: true
|
|
2166
|
+
});
|
|
2167
|
+
return data;
|
|
2168
|
+
},
|
|
2169
|
+
queryKey: listModelProviderConfigsInfiniteQueryKey(options)
|
|
2170
|
+
}
|
|
2171
|
+
);
|
|
2172
|
+
return opts;
|
|
2173
|
+
};
|
|
2174
|
+
var createModelProviderConfigMutation = (options) => {
|
|
2175
|
+
const mutationOptions = {
|
|
2176
|
+
mutationFn: async (fnOptions) => {
|
|
2177
|
+
const { data } = await createModelProviderConfig({
|
|
2178
|
+
...options,
|
|
2179
|
+
...fnOptions,
|
|
2180
|
+
throwOnError: true
|
|
2181
|
+
});
|
|
2182
|
+
return data;
|
|
2183
|
+
}
|
|
2184
|
+
};
|
|
2185
|
+
return mutationOptions;
|
|
2186
|
+
};
|
|
2187
|
+
var deleteModelProviderConfigMutation = (options) => {
|
|
2188
|
+
const mutationOptions = {
|
|
2189
|
+
mutationFn: async (fnOptions) => {
|
|
2190
|
+
const { data } = await deleteModelProviderConfig({
|
|
2191
|
+
...options,
|
|
2192
|
+
...fnOptions,
|
|
2193
|
+
throwOnError: true
|
|
2194
|
+
});
|
|
2195
|
+
return data;
|
|
2196
|
+
}
|
|
2197
|
+
};
|
|
2198
|
+
return mutationOptions;
|
|
2199
|
+
};
|
|
2200
|
+
var getModelProviderConfigQueryKey = (options) => createQueryKey("getModelProviderConfig", options);
|
|
2201
|
+
var getModelProviderConfigOptions = (options) => queryOptions({
|
|
2202
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2203
|
+
const { data } = await getModelProviderConfig({
|
|
2204
|
+
...options,
|
|
2205
|
+
...queryKey[0],
|
|
2206
|
+
signal,
|
|
2207
|
+
throwOnError: true
|
|
2208
|
+
});
|
|
2209
|
+
return data;
|
|
2210
|
+
},
|
|
2211
|
+
queryKey: getModelProviderConfigQueryKey(options)
|
|
2212
|
+
});
|
|
2213
|
+
var updateModelProviderConfigMutation = (options) => {
|
|
2214
|
+
const mutationOptions = {
|
|
2215
|
+
mutationFn: async (fnOptions) => {
|
|
2216
|
+
const { data } = await updateModelProviderConfig({
|
|
2217
|
+
...options,
|
|
2218
|
+
...fnOptions,
|
|
2219
|
+
throwOnError: true
|
|
2220
|
+
});
|
|
2221
|
+
return data;
|
|
2222
|
+
}
|
|
2223
|
+
};
|
|
2224
|
+
return mutationOptions;
|
|
2225
|
+
};
|
|
2226
|
+
var getModelCatalogQueryKey = (options) => createQueryKey("getModelCatalog", options);
|
|
2227
|
+
var getModelCatalogOptions = (options) => queryOptions({
|
|
2228
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2229
|
+
const { data } = await getModelCatalog({
|
|
2230
|
+
...options,
|
|
2231
|
+
...queryKey[0],
|
|
2232
|
+
signal,
|
|
2233
|
+
throwOnError: true
|
|
2234
|
+
});
|
|
2235
|
+
return data;
|
|
2236
|
+
},
|
|
2237
|
+
queryKey: getModelCatalogQueryKey(options)
|
|
2238
|
+
});
|
|
2239
|
+
var listConfiguredModelsQueryKey = (options) => createQueryKey("listConfiguredModels", options);
|
|
2240
|
+
var listConfiguredModelsOptions = (options) => queryOptions({
|
|
2241
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2242
|
+
const { data } = await listConfiguredModels({
|
|
2243
|
+
...options,
|
|
2244
|
+
...queryKey[0],
|
|
2245
|
+
signal,
|
|
2246
|
+
throwOnError: true
|
|
2247
|
+
});
|
|
2248
|
+
return data;
|
|
2249
|
+
},
|
|
2250
|
+
queryKey: listConfiguredModelsQueryKey(options)
|
|
2251
|
+
});
|
|
2252
|
+
var listConfiguredModelsInfiniteQueryKey = (options) => createQueryKey("listConfiguredModels", options, true);
|
|
2253
|
+
var listConfiguredModelsInfiniteOptions = (options) => {
|
|
2254
|
+
const opts = infiniteQueryOptions(
|
|
2255
|
+
// @ts-ignore
|
|
2256
|
+
{
|
|
2257
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
2258
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
2259
|
+
query: {
|
|
2260
|
+
cursor: pageParam
|
|
2261
|
+
}
|
|
2262
|
+
};
|
|
2263
|
+
const params = createInfiniteParams(queryKey, page);
|
|
2264
|
+
const { data } = await listConfiguredModels({
|
|
2265
|
+
...options,
|
|
2266
|
+
...params,
|
|
2267
|
+
signal,
|
|
2268
|
+
throwOnError: true
|
|
2269
|
+
});
|
|
2270
|
+
return data;
|
|
2271
|
+
},
|
|
2272
|
+
queryKey: listConfiguredModelsInfiniteQueryKey(options)
|
|
2273
|
+
}
|
|
2274
|
+
);
|
|
2275
|
+
return opts;
|
|
2276
|
+
};
|
|
2277
|
+
var createConfiguredModelMutation = (options) => {
|
|
2278
|
+
const mutationOptions = {
|
|
2279
|
+
mutationFn: async (fnOptions) => {
|
|
2280
|
+
const { data } = await createConfiguredModel({
|
|
2281
|
+
...options,
|
|
2282
|
+
...fnOptions,
|
|
2283
|
+
throwOnError: true
|
|
2284
|
+
});
|
|
2285
|
+
return data;
|
|
2286
|
+
}
|
|
2287
|
+
};
|
|
2288
|
+
return mutationOptions;
|
|
2289
|
+
};
|
|
2290
|
+
var deleteConfiguredModelMutation = (options) => {
|
|
2291
|
+
const mutationOptions = {
|
|
2292
|
+
mutationFn: async (fnOptions) => {
|
|
2293
|
+
const { data } = await deleteConfiguredModel({
|
|
2294
|
+
...options,
|
|
2295
|
+
...fnOptions,
|
|
2296
|
+
throwOnError: true
|
|
2297
|
+
});
|
|
2298
|
+
return data;
|
|
2299
|
+
}
|
|
2300
|
+
};
|
|
2301
|
+
return mutationOptions;
|
|
2302
|
+
};
|
|
2303
|
+
var updateConfiguredModelMutation = (options) => {
|
|
2304
|
+
const mutationOptions = {
|
|
2305
|
+
mutationFn: async (fnOptions) => {
|
|
2306
|
+
const { data } = await updateConfiguredModel({
|
|
2307
|
+
...options,
|
|
2308
|
+
...fnOptions,
|
|
2309
|
+
throwOnError: true
|
|
2310
|
+
});
|
|
2311
|
+
return data;
|
|
2312
|
+
}
|
|
2313
|
+
};
|
|
2314
|
+
return mutationOptions;
|
|
2315
|
+
};
|
|
2316
|
+
var listProjectModelGrantsQueryKey = (options) => createQueryKey("listProjectModelGrants", options);
|
|
2317
|
+
var listProjectModelGrantsOptions = (options) => queryOptions({
|
|
2318
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2319
|
+
const { data } = await listProjectModelGrants({
|
|
2320
|
+
...options,
|
|
2321
|
+
...queryKey[0],
|
|
2322
|
+
signal,
|
|
2323
|
+
throwOnError: true
|
|
2324
|
+
});
|
|
2325
|
+
return data;
|
|
2326
|
+
},
|
|
2327
|
+
queryKey: listProjectModelGrantsQueryKey(options)
|
|
2328
|
+
});
|
|
2329
|
+
var listProjectModelGrantsInfiniteQueryKey = (options) => createQueryKey("listProjectModelGrants", options, true);
|
|
2330
|
+
var listProjectModelGrantsInfiniteOptions = (options) => {
|
|
2331
|
+
const opts = infiniteQueryOptions(
|
|
2332
|
+
// @ts-ignore
|
|
2333
|
+
{
|
|
2334
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
2335
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
2336
|
+
query: {
|
|
2337
|
+
cursor: pageParam
|
|
2338
|
+
}
|
|
2339
|
+
};
|
|
2340
|
+
const params = createInfiniteParams(queryKey, page);
|
|
2341
|
+
const { data } = await listProjectModelGrants({
|
|
2342
|
+
...options,
|
|
2343
|
+
...params,
|
|
2344
|
+
signal,
|
|
2345
|
+
throwOnError: true
|
|
2346
|
+
});
|
|
2347
|
+
return data;
|
|
2348
|
+
},
|
|
2349
|
+
queryKey: listProjectModelGrantsInfiniteQueryKey(options)
|
|
2350
|
+
}
|
|
2351
|
+
);
|
|
2352
|
+
return opts;
|
|
2353
|
+
};
|
|
2354
|
+
var createProjectModelGrantMutation = (options) => {
|
|
2355
|
+
const mutationOptions = {
|
|
2356
|
+
mutationFn: async (fnOptions) => {
|
|
2357
|
+
const { data } = await createProjectModelGrant({
|
|
2358
|
+
...options,
|
|
2359
|
+
...fnOptions,
|
|
2360
|
+
throwOnError: true
|
|
2361
|
+
});
|
|
2362
|
+
return data;
|
|
2363
|
+
}
|
|
2364
|
+
};
|
|
2365
|
+
return mutationOptions;
|
|
2366
|
+
};
|
|
2367
|
+
var deleteProjectModelGrantMutation = (options) => {
|
|
2368
|
+
const mutationOptions = {
|
|
2369
|
+
mutationFn: async (fnOptions) => {
|
|
2370
|
+
const { data } = await deleteProjectModelGrant({
|
|
2371
|
+
...options,
|
|
2372
|
+
...fnOptions,
|
|
2373
|
+
throwOnError: true
|
|
2374
|
+
});
|
|
2375
|
+
return data;
|
|
2376
|
+
}
|
|
2377
|
+
};
|
|
2378
|
+
return mutationOptions;
|
|
2379
|
+
};
|
|
2380
|
+
var updateProjectModelGrantMutation = (options) => {
|
|
2381
|
+
const mutationOptions = {
|
|
2382
|
+
mutationFn: async (fnOptions) => {
|
|
2383
|
+
const { data } = await updateProjectModelGrant({
|
|
2384
|
+
...options,
|
|
2385
|
+
...fnOptions,
|
|
2386
|
+
throwOnError: true
|
|
2387
|
+
});
|
|
2388
|
+
return data;
|
|
2389
|
+
}
|
|
2390
|
+
};
|
|
2391
|
+
return mutationOptions;
|
|
2392
|
+
};
|
|
2393
|
+
var listMachinePoolsQueryKey = (options) => createQueryKey("listMachinePools", options);
|
|
2394
|
+
var listMachinePoolsOptions = (options) => queryOptions({
|
|
2395
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2396
|
+
const { data } = await listMachinePools({
|
|
2397
|
+
...options,
|
|
2398
|
+
...queryKey[0],
|
|
2399
|
+
signal,
|
|
2400
|
+
throwOnError: true
|
|
2401
|
+
});
|
|
2402
|
+
return data;
|
|
2403
|
+
},
|
|
2404
|
+
queryKey: listMachinePoolsQueryKey(options)
|
|
2405
|
+
});
|
|
2406
|
+
var listMachinePoolsInfiniteQueryKey = (options) => createQueryKey("listMachinePools", options, true);
|
|
2407
|
+
var listMachinePoolsInfiniteOptions = (options) => {
|
|
2408
|
+
const opts = infiniteQueryOptions(
|
|
2409
|
+
// @ts-ignore
|
|
2410
|
+
{
|
|
2411
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
2412
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
2413
|
+
query: {
|
|
2414
|
+
cursor: pageParam
|
|
2415
|
+
}
|
|
2416
|
+
};
|
|
2417
|
+
const params = createInfiniteParams(queryKey, page);
|
|
2418
|
+
const { data } = await listMachinePools({
|
|
2419
|
+
...options,
|
|
2420
|
+
...params,
|
|
2421
|
+
signal,
|
|
2422
|
+
throwOnError: true
|
|
2423
|
+
});
|
|
2424
|
+
return data;
|
|
2425
|
+
},
|
|
2426
|
+
queryKey: listMachinePoolsInfiniteQueryKey(options)
|
|
2427
|
+
}
|
|
2428
|
+
);
|
|
2429
|
+
return opts;
|
|
2430
|
+
};
|
|
2431
|
+
var createMachinePoolMutation = (options) => {
|
|
2432
|
+
const mutationOptions = {
|
|
2433
|
+
mutationFn: async (fnOptions) => {
|
|
2434
|
+
const { data } = await createMachinePool({
|
|
2435
|
+
...options,
|
|
2436
|
+
...fnOptions,
|
|
2437
|
+
throwOnError: true
|
|
2438
|
+
});
|
|
2439
|
+
return data;
|
|
2440
|
+
}
|
|
2441
|
+
};
|
|
2442
|
+
return mutationOptions;
|
|
2443
|
+
};
|
|
2444
|
+
var deleteMachinePoolMutation = (options) => {
|
|
2445
|
+
const mutationOptions = {
|
|
2446
|
+
mutationFn: async (fnOptions) => {
|
|
2447
|
+
const { data } = await deleteMachinePool({
|
|
2448
|
+
...options,
|
|
2449
|
+
...fnOptions,
|
|
2450
|
+
throwOnError: true
|
|
2451
|
+
});
|
|
2452
|
+
return data;
|
|
2453
|
+
}
|
|
2454
|
+
};
|
|
2455
|
+
return mutationOptions;
|
|
2456
|
+
};
|
|
2457
|
+
var getMachinePoolQueryKey = (options) => createQueryKey("getMachinePool", options);
|
|
2458
|
+
var getMachinePoolOptions = (options) => queryOptions({
|
|
2459
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2460
|
+
const { data } = await getMachinePool({
|
|
2461
|
+
...options,
|
|
2462
|
+
...queryKey[0],
|
|
2463
|
+
signal,
|
|
2464
|
+
throwOnError: true
|
|
2465
|
+
});
|
|
2466
|
+
return data;
|
|
2467
|
+
},
|
|
2468
|
+
queryKey: getMachinePoolQueryKey(options)
|
|
2469
|
+
});
|
|
2470
|
+
var updateMachinePoolMutation = (options) => {
|
|
2471
|
+
const mutationOptions = {
|
|
2472
|
+
mutationFn: async (fnOptions) => {
|
|
2473
|
+
const { data } = await updateMachinePool({
|
|
2474
|
+
...options,
|
|
2475
|
+
...fnOptions,
|
|
2476
|
+
throwOnError: true
|
|
2477
|
+
});
|
|
2478
|
+
return data;
|
|
2479
|
+
}
|
|
2480
|
+
};
|
|
2481
|
+
return mutationOptions;
|
|
2482
|
+
};
|
|
2483
|
+
var listProjectMachinePoolGrantsQueryKey = (options) => createQueryKey("listProjectMachinePoolGrants", options);
|
|
2484
|
+
var listProjectMachinePoolGrantsOptions = (options) => queryOptions({
|
|
2485
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2486
|
+
const { data } = await listProjectMachinePoolGrants({
|
|
2487
|
+
...options,
|
|
2488
|
+
...queryKey[0],
|
|
2489
|
+
signal,
|
|
2490
|
+
throwOnError: true
|
|
2491
|
+
});
|
|
2492
|
+
return data;
|
|
2493
|
+
},
|
|
2494
|
+
queryKey: listProjectMachinePoolGrantsQueryKey(options)
|
|
2495
|
+
});
|
|
2496
|
+
var listProjectMachinePoolGrantsInfiniteQueryKey = (options) => createQueryKey("listProjectMachinePoolGrants", options, true);
|
|
2497
|
+
var listProjectMachinePoolGrantsInfiniteOptions = (options) => {
|
|
2498
|
+
const opts = infiniteQueryOptions(
|
|
2499
|
+
// @ts-ignore
|
|
2500
|
+
{
|
|
2501
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
2502
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
2503
|
+
query: {
|
|
2504
|
+
cursor: pageParam
|
|
2505
|
+
}
|
|
2506
|
+
};
|
|
2507
|
+
const params = createInfiniteParams(queryKey, page);
|
|
2508
|
+
const { data } = await listProjectMachinePoolGrants({
|
|
2509
|
+
...options,
|
|
2510
|
+
...params,
|
|
2511
|
+
signal,
|
|
2512
|
+
throwOnError: true
|
|
2513
|
+
});
|
|
2514
|
+
return data;
|
|
2515
|
+
},
|
|
2516
|
+
queryKey: listProjectMachinePoolGrantsInfiniteQueryKey(options)
|
|
2517
|
+
}
|
|
2518
|
+
);
|
|
2519
|
+
return opts;
|
|
2520
|
+
};
|
|
2521
|
+
var createProjectMachinePoolGrantMutation = (options) => {
|
|
2522
|
+
const mutationOptions = {
|
|
2523
|
+
mutationFn: async (fnOptions) => {
|
|
2524
|
+
const { data } = await createProjectMachinePoolGrant({
|
|
2525
|
+
...options,
|
|
2526
|
+
...fnOptions,
|
|
2527
|
+
throwOnError: true
|
|
2528
|
+
});
|
|
2529
|
+
return data;
|
|
2530
|
+
}
|
|
2531
|
+
};
|
|
2532
|
+
return mutationOptions;
|
|
2533
|
+
};
|
|
2534
|
+
var deleteProjectMachinePoolGrantMutation = (options) => {
|
|
2535
|
+
const mutationOptions = {
|
|
2536
|
+
mutationFn: async (fnOptions) => {
|
|
2537
|
+
const { data } = await deleteProjectMachinePoolGrant({
|
|
2538
|
+
...options,
|
|
2539
|
+
...fnOptions,
|
|
2540
|
+
throwOnError: true
|
|
2541
|
+
});
|
|
2542
|
+
return data;
|
|
2543
|
+
}
|
|
2544
|
+
};
|
|
2545
|
+
return mutationOptions;
|
|
2546
|
+
};
|
|
2547
|
+
var getProjectMachinePoolGrantQueryKey = (options) => createQueryKey("getProjectMachinePoolGrant", options);
|
|
2548
|
+
var getProjectMachinePoolGrantOptions = (options) => queryOptions({
|
|
2549
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2550
|
+
const { data } = await getProjectMachinePoolGrant({
|
|
2551
|
+
...options,
|
|
2552
|
+
...queryKey[0],
|
|
2553
|
+
signal,
|
|
2554
|
+
throwOnError: true
|
|
2555
|
+
});
|
|
2556
|
+
return data;
|
|
2557
|
+
},
|
|
2558
|
+
queryKey: getProjectMachinePoolGrantQueryKey(options)
|
|
2559
|
+
});
|
|
2560
|
+
var updateProjectMachinePoolGrantMutation = (options) => {
|
|
2561
|
+
const mutationOptions = {
|
|
2562
|
+
mutationFn: async (fnOptions) => {
|
|
2563
|
+
const { data } = await updateProjectMachinePoolGrant({
|
|
2564
|
+
...options,
|
|
2565
|
+
...fnOptions,
|
|
2566
|
+
throwOnError: true
|
|
2567
|
+
});
|
|
2568
|
+
return data;
|
|
2569
|
+
}
|
|
2570
|
+
};
|
|
2571
|
+
return mutationOptions;
|
|
2572
|
+
};
|
|
2573
|
+
var listByoMachineDaemonTokensQueryKey = (options) => createQueryKey("listByoMachineDaemonTokens", options);
|
|
2574
|
+
var listByoMachineDaemonTokensOptions = (options) => queryOptions({
|
|
2575
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2576
|
+
const { data } = await listByoMachineDaemonTokens({
|
|
2577
|
+
...options,
|
|
2578
|
+
...queryKey[0],
|
|
2579
|
+
signal,
|
|
2580
|
+
throwOnError: true
|
|
2581
|
+
});
|
|
2582
|
+
return data;
|
|
2583
|
+
},
|
|
2584
|
+
queryKey: listByoMachineDaemonTokensQueryKey(options)
|
|
2585
|
+
});
|
|
2586
|
+
var listByoMachineDaemonTokensInfiniteQueryKey = (options) => createQueryKey("listByoMachineDaemonTokens", options, true);
|
|
2587
|
+
var listByoMachineDaemonTokensInfiniteOptions = (options) => {
|
|
2588
|
+
const opts = infiniteQueryOptions(
|
|
2589
|
+
// @ts-ignore
|
|
2590
|
+
{
|
|
2591
|
+
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
2592
|
+
const page = typeof pageParam === "object" ? pageParam : {
|
|
2593
|
+
query: {
|
|
2594
|
+
cursor: pageParam
|
|
2595
|
+
}
|
|
2596
|
+
};
|
|
2597
|
+
const params = createInfiniteParams(queryKey, page);
|
|
2598
|
+
const { data } = await listByoMachineDaemonTokens({
|
|
2599
|
+
...options,
|
|
2600
|
+
...params,
|
|
2601
|
+
signal,
|
|
2602
|
+
throwOnError: true
|
|
2603
|
+
});
|
|
2604
|
+
return data;
|
|
2605
|
+
},
|
|
2606
|
+
queryKey: listByoMachineDaemonTokensInfiniteQueryKey(options)
|
|
2607
|
+
}
|
|
2608
|
+
);
|
|
2609
|
+
return opts;
|
|
2610
|
+
};
|
|
2611
|
+
var createByoMachineDaemonTokenMutation = (options) => {
|
|
2612
|
+
const mutationOptions = {
|
|
2613
|
+
mutationFn: async (fnOptions) => {
|
|
2614
|
+
const { data } = await createByoMachineDaemonToken({
|
|
2615
|
+
...options,
|
|
2616
|
+
...fnOptions,
|
|
2617
|
+
throwOnError: true
|
|
2618
|
+
});
|
|
2619
|
+
return data;
|
|
2620
|
+
}
|
|
2621
|
+
};
|
|
2622
|
+
return mutationOptions;
|
|
2623
|
+
};
|
|
2624
|
+
var revokeMachineDaemonTokenMutation = (options) => {
|
|
2625
|
+
const mutationOptions = {
|
|
2626
|
+
mutationFn: async (fnOptions) => {
|
|
2627
|
+
const { data } = await revokeMachineDaemonToken({
|
|
2628
|
+
...options,
|
|
2629
|
+
...fnOptions,
|
|
2630
|
+
throwOnError: true
|
|
2631
|
+
});
|
|
2632
|
+
return data;
|
|
2633
|
+
}
|
|
2634
|
+
};
|
|
2635
|
+
return mutationOptions;
|
|
2636
|
+
};
|
|
2637
|
+
var registerMachineDaemonRuntimeMutation = (options) => {
|
|
2638
|
+
const mutationOptions = {
|
|
2639
|
+
mutationFn: async (fnOptions) => {
|
|
2640
|
+
const { data } = await registerMachineDaemonRuntime({
|
|
2641
|
+
...options,
|
|
2642
|
+
...fnOptions,
|
|
2643
|
+
throwOnError: true
|
|
2644
|
+
});
|
|
2645
|
+
return data;
|
|
2646
|
+
}
|
|
2647
|
+
};
|
|
2648
|
+
return mutationOptions;
|
|
2649
|
+
};
|
|
2650
|
+
var socketMachineDaemonRuntimeQueryKey = (options) => createQueryKey("socketMachineDaemonRuntime", options);
|
|
2651
|
+
var socketMachineDaemonRuntimeOptions = (options) => queryOptions({
|
|
2652
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2653
|
+
const { data } = await socketMachineDaemonRuntime({
|
|
2654
|
+
...options,
|
|
2655
|
+
...queryKey[0],
|
|
2656
|
+
signal,
|
|
2657
|
+
throwOnError: true
|
|
2658
|
+
});
|
|
2659
|
+
return data;
|
|
2660
|
+
},
|
|
2661
|
+
queryKey: socketMachineDaemonRuntimeQueryKey(options)
|
|
2662
|
+
});
|
|
2663
|
+
var endMachineDaemonRuntimeMutation = (options) => {
|
|
2664
|
+
const mutationOptions = {
|
|
2665
|
+
mutationFn: async (fnOptions) => {
|
|
2666
|
+
const { data } = await endMachineDaemonRuntime({
|
|
2667
|
+
...options,
|
|
2668
|
+
...fnOptions,
|
|
2669
|
+
throwOnError: true
|
|
2670
|
+
});
|
|
2671
|
+
return data;
|
|
2672
|
+
}
|
|
2673
|
+
};
|
|
2674
|
+
return mutationOptions;
|
|
2675
|
+
};
|
|
2676
|
+
var sleepMachineDaemonRuntimeMutation = (options) => {
|
|
2677
|
+
const mutationOptions = {
|
|
2678
|
+
mutationFn: async (fnOptions) => {
|
|
2679
|
+
const { data } = await sleepMachineDaemonRuntime({
|
|
2680
|
+
...options,
|
|
2681
|
+
...fnOptions,
|
|
2682
|
+
throwOnError: true
|
|
2683
|
+
});
|
|
2684
|
+
return data;
|
|
2685
|
+
}
|
|
2686
|
+
};
|
|
2687
|
+
return mutationOptions;
|
|
2688
|
+
};
|
|
2689
|
+
var getDaemonSkillArchiveQueryKey = (options) => createQueryKey("getDaemonSkillArchive", options);
|
|
2690
|
+
var getDaemonSkillArchiveOptions = (options) => queryOptions({
|
|
2691
|
+
queryFn: async ({ queryKey, signal }) => {
|
|
2692
|
+
const { data } = await getDaemonSkillArchive({
|
|
2693
|
+
...options,
|
|
2694
|
+
...queryKey[0],
|
|
2695
|
+
signal,
|
|
2696
|
+
throwOnError: true
|
|
2697
|
+
});
|
|
2698
|
+
return data;
|
|
2699
|
+
},
|
|
2700
|
+
queryKey: getDaemonSkillArchiveQueryKey(options)
|
|
2701
|
+
});
|
|
2702
|
+
export {
|
|
2703
|
+
acceptInvitationMutation,
|
|
2704
|
+
archiveAgentMutation,
|
|
2705
|
+
bootstrapDaemonMutation,
|
|
2706
|
+
cancelAgentMutation,
|
|
2707
|
+
cancelQueuedBacklogInputMutation,
|
|
2708
|
+
connectByoMachineMutation,
|
|
2709
|
+
createAgentConfigMutation,
|
|
2710
|
+
createAgentInputMutation,
|
|
2711
|
+
createAgentMutation,
|
|
2712
|
+
createAgentProfileMutation,
|
|
2713
|
+
createByoMachineDaemonTokenMutation,
|
|
2714
|
+
createConfiguredModelMutation,
|
|
2715
|
+
createCronTriggerMutation,
|
|
2716
|
+
createIntegrationOAuthSetupMutation,
|
|
2717
|
+
createMachineMutation,
|
|
2718
|
+
createMachinePoolMutation,
|
|
2719
|
+
createModelProviderConfigMutation,
|
|
2720
|
+
createOrgApiKeyMutation,
|
|
2721
|
+
createOrgInvitationMutation,
|
|
2722
|
+
createOrganizationMutation,
|
|
2723
|
+
createPersonalAccessTokenMutation,
|
|
2724
|
+
createProjectMachineGrantMutation,
|
|
2725
|
+
createProjectMachinePoolGrantMutation,
|
|
2726
|
+
createProjectModelGrantMutation,
|
|
2727
|
+
createProjectMutation,
|
|
2728
|
+
createSecretGrantMutation,
|
|
2729
|
+
createSecretMutation,
|
|
2730
|
+
createSecretVersionMutation,
|
|
2731
|
+
createSkillGrantMutation,
|
|
2732
|
+
createSkillMutation,
|
|
2733
|
+
createSlackSetupMutation,
|
|
2734
|
+
declineInvitationMutation,
|
|
2735
|
+
deleteAgentProfileMutation,
|
|
2736
|
+
deleteConfiguredModelMutation,
|
|
2737
|
+
deleteCronTriggerMutation,
|
|
2738
|
+
deleteCurrentUserMutation,
|
|
2739
|
+
deleteIntegrationInstallMutation,
|
|
2740
|
+
deleteMachineMutation,
|
|
2741
|
+
deleteMachinePoolMutation,
|
|
2742
|
+
deleteModelProviderConfigMutation,
|
|
2743
|
+
deleteOrgInvitationMutation,
|
|
2744
|
+
deleteOrganizationMutation,
|
|
2745
|
+
deleteProjectMachineGrantMutation,
|
|
2746
|
+
deleteProjectMachinePoolGrantMutation,
|
|
2747
|
+
deleteProjectModelGrantMutation,
|
|
2748
|
+
deleteProjectMutation,
|
|
2749
|
+
deleteSecretGrantMutation,
|
|
2750
|
+
deleteSecretMutation,
|
|
2751
|
+
deleteSkillGrantMutation,
|
|
2752
|
+
deleteSkillMutation,
|
|
2753
|
+
demoteSteeringInputToQueuedMutation,
|
|
2754
|
+
endMachineDaemonRuntimeMutation,
|
|
2755
|
+
getActorOptions,
|
|
2756
|
+
getActorQueryKey,
|
|
2757
|
+
getAgentConfigOptions,
|
|
2758
|
+
getAgentConfigQueryKey,
|
|
2759
|
+
getAgentOptions,
|
|
2760
|
+
getAgentProfileOptions,
|
|
2761
|
+
getAgentProfileQueryKey,
|
|
2762
|
+
getAgentQueryKey,
|
|
2763
|
+
getArtifactContentOptions,
|
|
2764
|
+
getArtifactContentQueryKey,
|
|
2765
|
+
getArtifactOptions,
|
|
2766
|
+
getArtifactQueryKey,
|
|
2767
|
+
getCronTriggerOptions,
|
|
2768
|
+
getCronTriggerQueryKey,
|
|
2769
|
+
getCurrentUserOptions,
|
|
2770
|
+
getCurrentUserQueryKey,
|
|
2771
|
+
getDaemonSkillArchiveOptions,
|
|
2772
|
+
getDaemonSkillArchiveQueryKey,
|
|
2773
|
+
getMachineOptions,
|
|
2774
|
+
getMachinePoolOptions,
|
|
2775
|
+
getMachinePoolQueryKey,
|
|
2776
|
+
getMachineQueryKey,
|
|
2777
|
+
getModelCatalogOptions,
|
|
2778
|
+
getModelCatalogQueryKey,
|
|
2779
|
+
getModelProviderConfigOptions,
|
|
2780
|
+
getModelProviderConfigQueryKey,
|
|
2781
|
+
getOrgApiKeyOptions,
|
|
2782
|
+
getOrgApiKeyQueryKey,
|
|
2783
|
+
getOrgOverviewOptions,
|
|
2784
|
+
getOrgOverviewQueryKey,
|
|
2785
|
+
getProjectAvailableSecretOptions,
|
|
2786
|
+
getProjectAvailableSecretQueryKey,
|
|
2787
|
+
getProjectMachinePoolGrantOptions,
|
|
2788
|
+
getProjectMachinePoolGrantQueryKey,
|
|
2789
|
+
getSecretOptions,
|
|
2790
|
+
getSecretQueryKey,
|
|
2791
|
+
getSkillOptions,
|
|
2792
|
+
getSkillQueryKey,
|
|
2793
|
+
getToolCatalogOptions,
|
|
2794
|
+
getToolCatalogQueryKey,
|
|
2795
|
+
listActorsInfiniteOptions,
|
|
2796
|
+
listActorsInfiniteQueryKey,
|
|
2797
|
+
listActorsOptions,
|
|
2798
|
+
listActorsQueryKey,
|
|
2799
|
+
listAgentInteractionsInfiniteOptions,
|
|
2800
|
+
listAgentInteractionsInfiniteQueryKey,
|
|
2801
|
+
listAgentInteractionsOptions,
|
|
2802
|
+
listAgentInteractionsQueryKey,
|
|
2803
|
+
listAgentProfilesInfiniteOptions,
|
|
2804
|
+
listAgentProfilesInfiniteQueryKey,
|
|
2805
|
+
listAgentProfilesOptions,
|
|
2806
|
+
listAgentProfilesQueryKey,
|
|
2807
|
+
listAgentsInfiniteOptions,
|
|
2808
|
+
listAgentsInfiniteQueryKey,
|
|
2809
|
+
listAgentsOptions,
|
|
2810
|
+
listAgentsQueryKey,
|
|
2811
|
+
listByoMachineDaemonTokensInfiniteOptions,
|
|
2812
|
+
listByoMachineDaemonTokensInfiniteQueryKey,
|
|
2813
|
+
listByoMachineDaemonTokensOptions,
|
|
2814
|
+
listByoMachineDaemonTokensQueryKey,
|
|
2815
|
+
listConfiguredModelsInfiniteOptions,
|
|
2816
|
+
listConfiguredModelsInfiniteQueryKey,
|
|
2817
|
+
listConfiguredModelsOptions,
|
|
2818
|
+
listConfiguredModelsQueryKey,
|
|
2819
|
+
listCronTriggersInfiniteOptions,
|
|
2820
|
+
listCronTriggersInfiniteQueryKey,
|
|
2821
|
+
listCronTriggersOptions,
|
|
2822
|
+
listCronTriggersQueryKey,
|
|
2823
|
+
listEventsOptions,
|
|
2824
|
+
listEventsQueryKey,
|
|
2825
|
+
listIntegrationInstallsInfiniteOptions,
|
|
2826
|
+
listIntegrationInstallsInfiniteQueryKey,
|
|
2827
|
+
listIntegrationInstallsOptions,
|
|
2828
|
+
listIntegrationInstallsQueryKey,
|
|
2829
|
+
listMachinePoolsInfiniteOptions,
|
|
2830
|
+
listMachinePoolsInfiniteQueryKey,
|
|
2831
|
+
listMachinePoolsOptions,
|
|
2832
|
+
listMachinePoolsQueryKey,
|
|
2833
|
+
listMemberProjectAccessOptions,
|
|
2834
|
+
listMemberProjectAccessQueryKey,
|
|
2835
|
+
listModelProviderConfigsInfiniteOptions,
|
|
2836
|
+
listModelProviderConfigsInfiniteQueryKey,
|
|
2837
|
+
listModelProviderConfigsOptions,
|
|
2838
|
+
listModelProviderConfigsQueryKey,
|
|
2839
|
+
listOrgApiKeyProjectAccessOptions,
|
|
2840
|
+
listOrgApiKeyProjectAccessQueryKey,
|
|
2841
|
+
listOrgApiKeysInfiniteOptions,
|
|
2842
|
+
listOrgApiKeysInfiniteQueryKey,
|
|
2843
|
+
listOrgApiKeysOptions,
|
|
2844
|
+
listOrgApiKeysQueryKey,
|
|
2845
|
+
listOrgInvitationsInfiniteOptions,
|
|
2846
|
+
listOrgInvitationsInfiniteQueryKey,
|
|
2847
|
+
listOrgInvitationsOptions,
|
|
2848
|
+
listOrgInvitationsQueryKey,
|
|
2849
|
+
listOrgMembersInfiniteOptions,
|
|
2850
|
+
listOrgMembersInfiniteQueryKey,
|
|
2851
|
+
listOrgMembersOptions,
|
|
2852
|
+
listOrgMembersQueryKey,
|
|
2853
|
+
listPendingInvitationsInfiniteOptions,
|
|
2854
|
+
listPendingInvitationsInfiniteQueryKey,
|
|
2855
|
+
listPendingInvitationsOptions,
|
|
2856
|
+
listPendingInvitationsQueryKey,
|
|
2857
|
+
listPersonalAccessTokensInfiniteOptions,
|
|
2858
|
+
listPersonalAccessTokensInfiniteQueryKey,
|
|
2859
|
+
listPersonalAccessTokensOptions,
|
|
2860
|
+
listPersonalAccessTokensQueryKey,
|
|
2861
|
+
listProjectAvailableSecretsInfiniteOptions,
|
|
2862
|
+
listProjectAvailableSecretsInfiniteQueryKey,
|
|
2863
|
+
listProjectAvailableSecretsOptions,
|
|
2864
|
+
listProjectAvailableSecretsQueryKey,
|
|
2865
|
+
listProjectAvailableSkillsInfiniteOptions,
|
|
2866
|
+
listProjectAvailableSkillsInfiniteQueryKey,
|
|
2867
|
+
listProjectAvailableSkillsOptions,
|
|
2868
|
+
listProjectAvailableSkillsQueryKey,
|
|
2869
|
+
listProjectMachineGrantsInfiniteOptions,
|
|
2870
|
+
listProjectMachineGrantsInfiniteQueryKey,
|
|
2871
|
+
listProjectMachineGrantsOptions,
|
|
2872
|
+
listProjectMachineGrantsQueryKey,
|
|
2873
|
+
listProjectMachinePoolGrantsInfiniteOptions,
|
|
2874
|
+
listProjectMachinePoolGrantsInfiniteQueryKey,
|
|
2875
|
+
listProjectMachinePoolGrantsOptions,
|
|
2876
|
+
listProjectMachinePoolGrantsQueryKey,
|
|
2877
|
+
listProjectModelGrantsInfiniteOptions,
|
|
2878
|
+
listProjectModelGrantsInfiniteQueryKey,
|
|
2879
|
+
listProjectModelGrantsOptions,
|
|
2880
|
+
listProjectModelGrantsQueryKey,
|
|
2881
|
+
listQueuedBacklogInputsInfiniteOptions,
|
|
2882
|
+
listQueuedBacklogInputsInfiniteQueryKey,
|
|
2883
|
+
listQueuedBacklogInputsOptions,
|
|
2884
|
+
listQueuedBacklogInputsQueryKey,
|
|
2885
|
+
listSecretGrantsInfiniteOptions,
|
|
2886
|
+
listSecretGrantsInfiniteQueryKey,
|
|
2887
|
+
listSecretGrantsOptions,
|
|
2888
|
+
listSecretGrantsQueryKey,
|
|
2889
|
+
listSecretsInfiniteOptions,
|
|
2890
|
+
listSecretsInfiniteQueryKey,
|
|
2891
|
+
listSecretsOptions,
|
|
2892
|
+
listSecretsQueryKey,
|
|
2893
|
+
listSkillGrantsInfiniteOptions,
|
|
2894
|
+
listSkillGrantsInfiniteQueryKey,
|
|
2895
|
+
listSkillGrantsOptions,
|
|
2896
|
+
listSkillGrantsQueryKey,
|
|
2897
|
+
listSkillsInfiniteOptions,
|
|
2898
|
+
listSkillsInfiniteQueryKey,
|
|
2899
|
+
listSkillsOptions,
|
|
2900
|
+
listSkillsQueryKey,
|
|
2901
|
+
listToolCallsInfiniteOptions,
|
|
2902
|
+
listToolCallsInfiniteQueryKey,
|
|
2903
|
+
listToolCallsOptions,
|
|
2904
|
+
listToolCallsQueryKey,
|
|
2905
|
+
listTurnEventsOptions,
|
|
2906
|
+
listTurnEventsQueryKey,
|
|
2907
|
+
listTurnsOptions,
|
|
2908
|
+
listTurnsQueryKey,
|
|
2909
|
+
listVisibleMachinesInfiniteOptions,
|
|
2910
|
+
listVisibleMachinesInfiniteQueryKey,
|
|
2911
|
+
listVisibleMachinesOptions,
|
|
2912
|
+
listVisibleMachinesQueryKey,
|
|
2913
|
+
listVisibleProjectMachinesInfiniteOptions,
|
|
2914
|
+
listVisibleProjectMachinesInfiniteQueryKey,
|
|
2915
|
+
listVisibleProjectMachinesOptions,
|
|
2916
|
+
listVisibleProjectMachinesQueryKey,
|
|
2917
|
+
listVisibleProjectsInfiniteOptions,
|
|
2918
|
+
listVisibleProjectsInfiniteQueryKey,
|
|
2919
|
+
listVisibleProjectsOptions,
|
|
2920
|
+
listVisibleProjectsQueryKey,
|
|
2921
|
+
moveQueuedBacklogInputMutation,
|
|
2922
|
+
promoteQueuedInputToSteeringMutation,
|
|
2923
|
+
putActorMutation,
|
|
2924
|
+
recordMachineFailureMutation,
|
|
2925
|
+
registerMachineDaemonRuntimeMutation,
|
|
2926
|
+
removeMemberProjectAccessMutation,
|
|
2927
|
+
removeOrgApiKeyProjectRoleMutation,
|
|
2928
|
+
removeOrgMemberMutation,
|
|
2929
|
+
renameAgentProfileMutation,
|
|
2930
|
+
resolveAgentInteractionMutation,
|
|
2931
|
+
revokeMachineDaemonTokenMutation,
|
|
2932
|
+
revokeOrgApiKeyMutation,
|
|
2933
|
+
revokePersonalAccessTokenMutation,
|
|
2934
|
+
setMemberProjectAccessMutation,
|
|
2935
|
+
setOrgApiKeyProjectRoleMutation,
|
|
2936
|
+
sleepMachineDaemonRuntimeMutation,
|
|
2937
|
+
socketMachineDaemonRuntimeOptions,
|
|
2938
|
+
socketMachineDaemonRuntimeQueryKey,
|
|
2939
|
+
startSecretMcpoAuthMutation,
|
|
2940
|
+
submitToolCallResultMutation,
|
|
2941
|
+
updateAgentConfigMutation,
|
|
2942
|
+
updateAgentProfileMutation,
|
|
2943
|
+
updateConfiguredModelMutation,
|
|
2944
|
+
updateCronTriggerMutation,
|
|
2945
|
+
updateMachineMutation,
|
|
2946
|
+
updateMachinePoolMutation,
|
|
2947
|
+
updateModelProviderConfigMutation,
|
|
2948
|
+
updateOrgApiKeyMutation,
|
|
2949
|
+
updateOrgMemberMutation,
|
|
2950
|
+
updateProjectMachinePoolGrantMutation,
|
|
2951
|
+
updateProjectModelGrantMutation,
|
|
2952
|
+
updateSecretMutation
|
|
2953
|
+
};
|
|
2954
|
+
//# sourceMappingURL=tanstack.js.map
|