@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.
@@ -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