@relevanceai/sdk 1.66.0 → 1.68.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.
|
@@ -7,112 +7,592 @@ interface definitions {
|
|
|
7
7
|
*/
|
|
8
8
|
export interface paths {
|
|
9
9
|
"/deployables/create": {
|
|
10
|
-
/**
|
|
10
|
+
/**
|
|
11
|
+
* Create a private deployable.
|
|
12
|
+
*
|
|
13
|
+
* ### Required permissions
|
|
14
|
+
* > [
|
|
15
|
+
* {
|
|
16
|
+
* "actions": [
|
|
17
|
+
* "deployables:write",
|
|
18
|
+
* "datasets:read"
|
|
19
|
+
* ],
|
|
20
|
+
* "datasets": [
|
|
21
|
+
* {
|
|
22
|
+
* "body": "dataset_id"
|
|
23
|
+
* }
|
|
24
|
+
* ]
|
|
25
|
+
* }
|
|
26
|
+
* ]
|
|
27
|
+
*/
|
|
11
28
|
post: operations["CreateDeployable"];
|
|
12
29
|
};
|
|
13
30
|
"/deployables/{deployable_id}/get": {
|
|
14
|
-
/**
|
|
31
|
+
/**
|
|
32
|
+
* Get a deployable.
|
|
33
|
+
*
|
|
34
|
+
* ### Required permissions
|
|
35
|
+
* > [
|
|
36
|
+
* {
|
|
37
|
+
* "actions": [
|
|
38
|
+
* "deployables:read"
|
|
39
|
+
* ],
|
|
40
|
+
* "deployables": [
|
|
41
|
+
* {
|
|
42
|
+
* "params": "deployable_id"
|
|
43
|
+
* }
|
|
44
|
+
* ]
|
|
45
|
+
* }
|
|
46
|
+
* ]
|
|
47
|
+
*/
|
|
15
48
|
get: operations["GetDeployable"];
|
|
16
49
|
};
|
|
17
50
|
"/deployables/{deployable_id}/update": {
|
|
18
|
-
/**
|
|
51
|
+
/**
|
|
52
|
+
* Update a deployable
|
|
53
|
+
*
|
|
54
|
+
* ### Required permissions
|
|
55
|
+
* > [
|
|
56
|
+
* {
|
|
57
|
+
* "actions": [
|
|
58
|
+
* "deployables:write"
|
|
59
|
+
* ],
|
|
60
|
+
* "deployables": [
|
|
61
|
+
* {
|
|
62
|
+
* "params": "deployable_id"
|
|
63
|
+
* }
|
|
64
|
+
* ]
|
|
65
|
+
* },
|
|
66
|
+
* {
|
|
67
|
+
* "actions": [
|
|
68
|
+
* "datasets:read"
|
|
69
|
+
* ],
|
|
70
|
+
* "datasets": [
|
|
71
|
+
* {
|
|
72
|
+
* "body": "dataset_id"
|
|
73
|
+
* }
|
|
74
|
+
* ]
|
|
75
|
+
* }
|
|
76
|
+
* ]
|
|
77
|
+
*/
|
|
19
78
|
post: operations["UpdateDeployable"];
|
|
20
79
|
};
|
|
21
80
|
"/deployables/delete": {
|
|
81
|
+
/**
|
|
82
|
+
* ### Required permissions
|
|
83
|
+
* > [
|
|
84
|
+
* {
|
|
85
|
+
* "actions": [
|
|
86
|
+
* "deployables:write"
|
|
87
|
+
* ],
|
|
88
|
+
* "deployables": [
|
|
89
|
+
* {
|
|
90
|
+
* "body": "id"
|
|
91
|
+
* }
|
|
92
|
+
* ]
|
|
93
|
+
* }
|
|
94
|
+
* ]
|
|
95
|
+
*/
|
|
22
96
|
post: operations["DeleteDeployable"];
|
|
23
97
|
};
|
|
24
98
|
"/deployables/{deployable_id}/share": {
|
|
25
|
-
/**
|
|
99
|
+
/**
|
|
100
|
+
* Share a private deployable.
|
|
101
|
+
*
|
|
102
|
+
* ### Required permissions
|
|
103
|
+
* > [
|
|
104
|
+
* {
|
|
105
|
+
* "actions": [
|
|
106
|
+
* "sharing:write",
|
|
107
|
+
* "deployables:read"
|
|
108
|
+
* ],
|
|
109
|
+
* "deployables": [
|
|
110
|
+
* {
|
|
111
|
+
* "params": "deployable_id"
|
|
112
|
+
* }
|
|
113
|
+
* ]
|
|
114
|
+
* }
|
|
115
|
+
* ]
|
|
116
|
+
*/
|
|
26
117
|
post: operations["CreateDeployableKey"];
|
|
27
118
|
};
|
|
28
119
|
"/deployables/{deployable_id}/invite": {
|
|
120
|
+
/**
|
|
121
|
+
* ### Required permissions
|
|
122
|
+
* > [
|
|
123
|
+
* {
|
|
124
|
+
* "actions": [
|
|
125
|
+
* "users:write",
|
|
126
|
+
* "deployables:read"
|
|
127
|
+
* ],
|
|
128
|
+
* "deployables": [
|
|
129
|
+
* {
|
|
130
|
+
* "params": "deployable_id"
|
|
131
|
+
* }
|
|
132
|
+
* ]
|
|
133
|
+
* }
|
|
134
|
+
* ]
|
|
135
|
+
*/
|
|
29
136
|
post: operations["CreateDeployableInvite"];
|
|
30
137
|
};
|
|
31
138
|
"/deployables/{deployable_id}/users/{user_id}/update": {
|
|
139
|
+
/**
|
|
140
|
+
* ### Required permissions
|
|
141
|
+
* > [
|
|
142
|
+
* {
|
|
143
|
+
* "actions": [
|
|
144
|
+
* "users:write",
|
|
145
|
+
* "deployables:read"
|
|
146
|
+
* ],
|
|
147
|
+
* "deployables": [
|
|
148
|
+
* {
|
|
149
|
+
* "params": "deployable_id"
|
|
150
|
+
* }
|
|
151
|
+
* ]
|
|
152
|
+
* }
|
|
153
|
+
* ]
|
|
154
|
+
*/
|
|
32
155
|
post: operations["UpdateUsersDeployablePermissions"];
|
|
33
156
|
};
|
|
34
157
|
"/deployables/{deployable_id}/private": {
|
|
35
|
-
/**
|
|
158
|
+
/**
|
|
159
|
+
* Unshare a shared deployable, making it private.
|
|
160
|
+
*
|
|
161
|
+
* ### Required permissions
|
|
162
|
+
* > [
|
|
163
|
+
* {
|
|
164
|
+
* "actions": [
|
|
165
|
+
* "sharing:write",
|
|
166
|
+
* "deployables:read"
|
|
167
|
+
* ],
|
|
168
|
+
* "deployables": [
|
|
169
|
+
* {
|
|
170
|
+
* "params": "deployable_id"
|
|
171
|
+
* }
|
|
172
|
+
* ]
|
|
173
|
+
* }
|
|
174
|
+
* ]
|
|
175
|
+
*/
|
|
36
176
|
post: operations["DeleteDeployableKey"];
|
|
37
177
|
};
|
|
38
178
|
"/deployables/list": {
|
|
39
|
-
/**
|
|
179
|
+
/**
|
|
180
|
+
* List all deployables.
|
|
181
|
+
*
|
|
182
|
+
* ### Required permissions
|
|
183
|
+
* > [
|
|
184
|
+
* {
|
|
185
|
+
* "actions": []
|
|
186
|
+
* }
|
|
187
|
+
* ]
|
|
188
|
+
*/
|
|
40
189
|
get: operations["ListDeployables"];
|
|
41
190
|
};
|
|
191
|
+
"/deployablegroups/{deployablegroup_id}/delete": {
|
|
192
|
+
/**
|
|
193
|
+
* ### Required permissions
|
|
194
|
+
* > []
|
|
195
|
+
*/
|
|
196
|
+
post: operations["DeleteDeployableGroup"];
|
|
197
|
+
};
|
|
198
|
+
"/deployablegroups/list": {
|
|
199
|
+
/**
|
|
200
|
+
* ### Required permissions
|
|
201
|
+
* > []
|
|
202
|
+
*/
|
|
203
|
+
post: operations["ListDeployableGroups"];
|
|
204
|
+
};
|
|
205
|
+
"/deployablegroups/create": {
|
|
206
|
+
/**
|
|
207
|
+
* ### Required permissions
|
|
208
|
+
* > []
|
|
209
|
+
*/
|
|
210
|
+
post: operations["CreateDeployableGroup"];
|
|
211
|
+
};
|
|
212
|
+
"/deployablegroups/{deployablegroup_id}/get": {
|
|
213
|
+
/**
|
|
214
|
+
* ### Required permissions
|
|
215
|
+
* > []
|
|
216
|
+
*/
|
|
217
|
+
get: operations["GetDeployableGroup"];
|
|
218
|
+
};
|
|
219
|
+
"/deployablegroups/{deployablegroup_id}/update": {
|
|
220
|
+
/**
|
|
221
|
+
* ### Required permissions
|
|
222
|
+
* > []
|
|
223
|
+
*/
|
|
224
|
+
post: operations["UpdateDeployableGroup"];
|
|
225
|
+
};
|
|
226
|
+
"/deployablegroups/{deployablegroup_id}/share": {
|
|
227
|
+
/**
|
|
228
|
+
* Share a private deployable group. Required read access to all deployables that are shared, and the datasets deployables are tied to.
|
|
229
|
+
*
|
|
230
|
+
* ### Required permissions
|
|
231
|
+
* > [
|
|
232
|
+
* {
|
|
233
|
+
* "actions": [
|
|
234
|
+
* "sharing:write"
|
|
235
|
+
* ]
|
|
236
|
+
* }
|
|
237
|
+
* ]
|
|
238
|
+
*/
|
|
239
|
+
post: operations["CreateDeployableGroupKey"];
|
|
240
|
+
};
|
|
241
|
+
"/deployablegroups/{deployablegroup_id}/private": {
|
|
242
|
+
/**
|
|
243
|
+
* Unshare a shared deployable group, making it private.
|
|
244
|
+
*
|
|
245
|
+
* ### Required permissions
|
|
246
|
+
* > [
|
|
247
|
+
* {
|
|
248
|
+
* "actions": [
|
|
249
|
+
* "sharing:write"
|
|
250
|
+
* ]
|
|
251
|
+
* }
|
|
252
|
+
* ]
|
|
253
|
+
*/
|
|
254
|
+
post: operations["DeleteDeployableGroupKey"];
|
|
255
|
+
};
|
|
42
256
|
"/projects/create": {
|
|
43
|
-
/**
|
|
257
|
+
/**
|
|
258
|
+
* Create a new Project that your user will have access to
|
|
259
|
+
*
|
|
260
|
+
* ### Required permissions
|
|
261
|
+
* > [
|
|
262
|
+
* {
|
|
263
|
+
* "actions": [
|
|
264
|
+
* "organizations:write"
|
|
265
|
+
* ],
|
|
266
|
+
* "organizations": [
|
|
267
|
+
* {
|
|
268
|
+
* "body": "organization_id"
|
|
269
|
+
* }
|
|
270
|
+
* ]
|
|
271
|
+
* }
|
|
272
|
+
* ]
|
|
273
|
+
*/
|
|
44
274
|
post: operations["CreateProject"];
|
|
45
275
|
};
|
|
46
276
|
"/projects/update": {
|
|
47
|
-
/**
|
|
277
|
+
/**
|
|
278
|
+
* Update metadata of a Project
|
|
279
|
+
*
|
|
280
|
+
* ### Required permissions
|
|
281
|
+
* > [
|
|
282
|
+
* {
|
|
283
|
+
* "actions": [
|
|
284
|
+
* "admin"
|
|
285
|
+
* ]
|
|
286
|
+
* }
|
|
287
|
+
* ]
|
|
288
|
+
*/
|
|
48
289
|
post: operations["UpdateProject"];
|
|
49
290
|
};
|
|
50
291
|
"/projects/transfer_to_organization": {
|
|
51
|
-
/**
|
|
292
|
+
/**
|
|
293
|
+
* Tie a project to an organization. This requires admin privileges over project and organization.
|
|
294
|
+
*
|
|
295
|
+
* ### Required permissions
|
|
296
|
+
* > [
|
|
297
|
+
* {
|
|
298
|
+
* "actions": [
|
|
299
|
+
* "admin"
|
|
300
|
+
* ],
|
|
301
|
+
* "projects": [
|
|
302
|
+
* {
|
|
303
|
+
* "user_info": "username"
|
|
304
|
+
* }
|
|
305
|
+
* ]
|
|
306
|
+
* },
|
|
307
|
+
* {
|
|
308
|
+
* "actions": [
|
|
309
|
+
* "organizations:write"
|
|
310
|
+
* ],
|
|
311
|
+
* "organizations": [
|
|
312
|
+
* {
|
|
313
|
+
* "body": "organization_id"
|
|
314
|
+
* }
|
|
315
|
+
* ]
|
|
316
|
+
* }
|
|
317
|
+
* ]
|
|
318
|
+
*/
|
|
52
319
|
post: operations["TransferProjectToOrganization"];
|
|
53
320
|
};
|
|
54
321
|
"/projects/list": {
|
|
55
|
-
/**
|
|
322
|
+
/**
|
|
323
|
+
* List all projects and their metadata
|
|
324
|
+
*
|
|
325
|
+
* ### Required permissions
|
|
326
|
+
* > []
|
|
327
|
+
*/
|
|
56
328
|
get: operations["ListProjects"];
|
|
57
329
|
};
|
|
58
330
|
"/auth/users/create": {
|
|
331
|
+
/**
|
|
332
|
+
* ### Required permissions
|
|
333
|
+
* > [
|
|
334
|
+
* {
|
|
335
|
+
* "actions": [
|
|
336
|
+
* "users:write"
|
|
337
|
+
* ]
|
|
338
|
+
* }
|
|
339
|
+
* ]
|
|
340
|
+
*/
|
|
59
341
|
post: operations["CreateUser"];
|
|
60
342
|
};
|
|
61
343
|
"/auth/users/list": {
|
|
344
|
+
/**
|
|
345
|
+
* ### Required permissions
|
|
346
|
+
* > [
|
|
347
|
+
* {
|
|
348
|
+
* "actions": []
|
|
349
|
+
* }
|
|
350
|
+
* ]
|
|
351
|
+
*/
|
|
62
352
|
post: operations["ListUsers"];
|
|
63
353
|
};
|
|
64
354
|
"/auth/is_authorized": {
|
|
355
|
+
/**
|
|
356
|
+
* ### Required permissions
|
|
357
|
+
* > []
|
|
358
|
+
*/
|
|
65
359
|
post: operations["IsUserAuthorized"];
|
|
66
360
|
};
|
|
67
361
|
"/auth/info": {
|
|
68
|
-
/**
|
|
362
|
+
/**
|
|
363
|
+
* Get user_id, key_id and permissions from an auth header.
|
|
364
|
+
*
|
|
365
|
+
* ### Required permissions
|
|
366
|
+
* > []
|
|
367
|
+
*/
|
|
69
368
|
get: operations["GetAuthHeaderInfo"];
|
|
70
369
|
};
|
|
71
370
|
"/auth/invite/create": {
|
|
72
|
-
/**
|
|
371
|
+
/**
|
|
372
|
+
* Invite a user to a project using either their email or their user_id
|
|
373
|
+
*
|
|
374
|
+
* ### Required permissions
|
|
375
|
+
* > [
|
|
376
|
+
* {
|
|
377
|
+
* "actions": [
|
|
378
|
+
* "users:write"
|
|
379
|
+
* ]
|
|
380
|
+
* }
|
|
381
|
+
* ]
|
|
382
|
+
*/
|
|
73
383
|
post: operations["CreateProjectInvite"];
|
|
74
384
|
};
|
|
75
385
|
"/auth/invite/list": {
|
|
386
|
+
/**
|
|
387
|
+
* ### Required permissions
|
|
388
|
+
* > []
|
|
389
|
+
*/
|
|
76
390
|
post: operations["ListProjectInvites"];
|
|
77
391
|
};
|
|
78
392
|
"/auth/invite/accept": {
|
|
393
|
+
/**
|
|
394
|
+
* ### Required permissions
|
|
395
|
+
* > []
|
|
396
|
+
*/
|
|
79
397
|
post: operations["AcceptProjectInvite"];
|
|
80
398
|
};
|
|
81
399
|
"/auth/invite/delete": {
|
|
400
|
+
/**
|
|
401
|
+
* ### Required permissions
|
|
402
|
+
* > [
|
|
403
|
+
* {
|
|
404
|
+
* "actions": [
|
|
405
|
+
* "users:write"
|
|
406
|
+
* ]
|
|
407
|
+
* }
|
|
408
|
+
* ]
|
|
409
|
+
*/
|
|
82
410
|
post: operations["DeleteProjectInvite"];
|
|
83
411
|
};
|
|
84
412
|
"/auth/invite/resend": {
|
|
413
|
+
/**
|
|
414
|
+
* ### Required permissions
|
|
415
|
+
* > [
|
|
416
|
+
* {
|
|
417
|
+
* "actions": [
|
|
418
|
+
* "users:write"
|
|
419
|
+
* ]
|
|
420
|
+
* }
|
|
421
|
+
* ]
|
|
422
|
+
*/
|
|
85
423
|
post: operations["ResendProjectInvite"];
|
|
86
424
|
};
|
|
87
425
|
"/auth/users/{user_id}": {
|
|
426
|
+
/**
|
|
427
|
+
* ### Required permissions
|
|
428
|
+
* > [
|
|
429
|
+
* {
|
|
430
|
+
* "users": [
|
|
431
|
+
* {
|
|
432
|
+
* "params": "user_id"
|
|
433
|
+
* }
|
|
434
|
+
* ],
|
|
435
|
+
* "actions": [
|
|
436
|
+
* "users:read"
|
|
437
|
+
* ]
|
|
438
|
+
* }
|
|
439
|
+
* ]
|
|
440
|
+
*/
|
|
88
441
|
get: operations["GetUser"];
|
|
89
442
|
};
|
|
90
443
|
"/auth/users/{user_id}/update": {
|
|
444
|
+
/**
|
|
445
|
+
* ### Required permissions
|
|
446
|
+
* > [
|
|
447
|
+
* {
|
|
448
|
+
* "users": [
|
|
449
|
+
* {
|
|
450
|
+
* "params": "user_id"
|
|
451
|
+
* }
|
|
452
|
+
* ],
|
|
453
|
+
* "actions": [
|
|
454
|
+
* "users:write"
|
|
455
|
+
* ]
|
|
456
|
+
* }
|
|
457
|
+
* ]
|
|
458
|
+
*/
|
|
91
459
|
post: operations["UpdateUser"];
|
|
92
460
|
};
|
|
93
461
|
"/auth/users/{user_id}/delete": {
|
|
94
|
-
/**
|
|
462
|
+
/**
|
|
463
|
+
* Deletes a User from ONLY your project. If they have permissions for other projects, they will still have acces to them.
|
|
464
|
+
*
|
|
465
|
+
* ### Required permissions
|
|
466
|
+
* > [
|
|
467
|
+
* {
|
|
468
|
+
* "users": [
|
|
469
|
+
* {
|
|
470
|
+
* "params": "user_id"
|
|
471
|
+
* }
|
|
472
|
+
* ],
|
|
473
|
+
* "actions": [
|
|
474
|
+
* "users:write"
|
|
475
|
+
* ]
|
|
476
|
+
* }
|
|
477
|
+
* ]
|
|
478
|
+
*/
|
|
95
479
|
post: operations["DeleteUser"];
|
|
96
480
|
};
|
|
97
481
|
"/auth/users/{user_id}/keys/create": {
|
|
482
|
+
/**
|
|
483
|
+
* ### Required permissions
|
|
484
|
+
* > [
|
|
485
|
+
* {
|
|
486
|
+
* "users": [
|
|
487
|
+
* {
|
|
488
|
+
* "params": "user_id"
|
|
489
|
+
* }
|
|
490
|
+
* ],
|
|
491
|
+
* "actions": [
|
|
492
|
+
* "users:write"
|
|
493
|
+
* ]
|
|
494
|
+
* }
|
|
495
|
+
* ]
|
|
496
|
+
*/
|
|
98
497
|
post: operations["CreateUserKey"];
|
|
99
498
|
};
|
|
100
499
|
"/auth/users/{user_id}/keys/list": {
|
|
500
|
+
/**
|
|
501
|
+
* ### Required permissions
|
|
502
|
+
* > [
|
|
503
|
+
* {
|
|
504
|
+
* "users": [
|
|
505
|
+
* {
|
|
506
|
+
* "params": "user_id"
|
|
507
|
+
* }
|
|
508
|
+
* ],
|
|
509
|
+
* "actions": [
|
|
510
|
+
* "users:read"
|
|
511
|
+
* ]
|
|
512
|
+
* }
|
|
513
|
+
* ]
|
|
514
|
+
*/
|
|
101
515
|
post: operations["ListUserKeys"];
|
|
102
516
|
};
|
|
103
517
|
"/auth/users/{user_id}/keys/delete": {
|
|
518
|
+
/**
|
|
519
|
+
* ### Required permissions
|
|
520
|
+
* > [
|
|
521
|
+
* {
|
|
522
|
+
* "users": [
|
|
523
|
+
* {
|
|
524
|
+
* "params": "user_id"
|
|
525
|
+
* }
|
|
526
|
+
* ],
|
|
527
|
+
* "actions": [
|
|
528
|
+
* "users:write"
|
|
529
|
+
* ]
|
|
530
|
+
* }
|
|
531
|
+
* ]
|
|
532
|
+
*/
|
|
104
533
|
post: operations["DeleteUserKey"];
|
|
105
534
|
};
|
|
106
535
|
"/datasets/{dataset_id}/cluster/centroids/insert": {
|
|
107
|
-
/**
|
|
536
|
+
/**
|
|
537
|
+
* Insert your own cluster centroids for it to be used in approximate search settings and cluster aggregations.
|
|
538
|
+
*
|
|
539
|
+
* ### Required permissions
|
|
540
|
+
* > [
|
|
541
|
+
* {
|
|
542
|
+
* "actions": [
|
|
543
|
+
* "datasets:write"
|
|
544
|
+
* ],
|
|
545
|
+
* "datasets": [
|
|
546
|
+
* {
|
|
547
|
+
* "params": "dataset_id"
|
|
548
|
+
* }
|
|
549
|
+
* ]
|
|
550
|
+
* }
|
|
551
|
+
* ]
|
|
552
|
+
*/
|
|
108
553
|
post: operations["InsertClusterCentroids"];
|
|
109
554
|
};
|
|
110
555
|
"/datasets/{dataset_id}/cluster/centroids/update": {
|
|
111
|
-
/**
|
|
556
|
+
/**
|
|
557
|
+
* Update your own cluster centroids for it to be used in approximate search settings and cluster aggregations. Will merge rather than replace centroids.
|
|
558
|
+
*
|
|
559
|
+
* ### Required permissions
|
|
560
|
+
* > [
|
|
561
|
+
* {
|
|
562
|
+
* "actions": [
|
|
563
|
+
* "datasets:write"
|
|
564
|
+
* ],
|
|
565
|
+
* "datasets": [
|
|
566
|
+
* {
|
|
567
|
+
* "params": "dataset_id"
|
|
568
|
+
* }
|
|
569
|
+
* ]
|
|
570
|
+
* }
|
|
571
|
+
* ]
|
|
572
|
+
*/
|
|
112
573
|
post: operations["UpdateClusterCentroids"];
|
|
113
574
|
};
|
|
114
575
|
"/datasets/{dataset_id}/cluster/centroids/compare_centroids": {
|
|
115
|
-
/**
|
|
576
|
+
/**
|
|
577
|
+
* For each centroid in a list of centroids, find the closest centroids in another set of centroids.
|
|
578
|
+
*
|
|
579
|
+
* ### Required permissions
|
|
580
|
+
* > [
|
|
581
|
+
* {
|
|
582
|
+
* "actions": [
|
|
583
|
+
* "datasets:read"
|
|
584
|
+
* ],
|
|
585
|
+
* "datasets": [
|
|
586
|
+
* {
|
|
587
|
+
* "params": "dataset_id"
|
|
588
|
+
* },
|
|
589
|
+
* {
|
|
590
|
+
* "body": "comparison_centroids.dataset_id"
|
|
591
|
+
* }
|
|
592
|
+
* ]
|
|
593
|
+
* }
|
|
594
|
+
* ]
|
|
595
|
+
*/
|
|
116
596
|
post: operations["CompareClusterCentroids"];
|
|
117
597
|
};
|
|
118
598
|
"/datasets/{dataset_id}/aggregate": {
|
|
@@ -171,78 +651,402 @@ export interface paths {
|
|
|
171
651
|
* {"title": {"title": "books", "frequency": 200, "documents": [{...}, {...}]}, {"title": "books", "frequency": 100, "documents": [{...}, {...}]}}
|
|
172
652
|
*
|
|
173
653
|
* For array-aggregations, you can add "agg": "array" into the aggregation query.
|
|
654
|
+
*
|
|
655
|
+
*
|
|
656
|
+
*
|
|
657
|
+
* ### Required permissions
|
|
658
|
+
* > [
|
|
659
|
+
* {
|
|
660
|
+
* "actions": [
|
|
661
|
+
* "datasets:read"
|
|
662
|
+
* ],
|
|
663
|
+
* "datasets": [
|
|
664
|
+
* {
|
|
665
|
+
* "params": "dataset_id"
|
|
666
|
+
* }
|
|
667
|
+
* ]
|
|
668
|
+
* }
|
|
669
|
+
* ]
|
|
174
670
|
*/
|
|
175
671
|
post: operations["Aggregate"];
|
|
176
672
|
};
|
|
177
673
|
"/datasets/{dataset_id}/cluster/aggregate": {
|
|
178
|
-
/**
|
|
674
|
+
/**
|
|
675
|
+
* Takes an aggregation query and gets the aggregate of each cluster in a collection. This helps you interpret each cluster and what is in them.
|
|
676
|
+
*
|
|
677
|
+
* ### Required permissions
|
|
678
|
+
* > [
|
|
679
|
+
* {
|
|
680
|
+
* "actions": [
|
|
681
|
+
* "datasets:read"
|
|
682
|
+
* ],
|
|
683
|
+
* "datasets": [
|
|
684
|
+
* {
|
|
685
|
+
* "params": "dataset_id"
|
|
686
|
+
* }
|
|
687
|
+
* ]
|
|
688
|
+
* }
|
|
689
|
+
* ]
|
|
690
|
+
*/
|
|
179
691
|
post: operations["AggregateClusters"];
|
|
180
692
|
};
|
|
181
693
|
"/datasets/{dataset_id}/cluster/facets": {
|
|
182
|
-
/**
|
|
694
|
+
/**
|
|
695
|
+
* Takes a high level aggregation of every field and every cluster in a collection. This helps you interpret each cluster and what is in them.
|
|
696
|
+
*
|
|
697
|
+
* ### Required permissions
|
|
698
|
+
* > [
|
|
699
|
+
* {
|
|
700
|
+
* "actions": [
|
|
701
|
+
* "datasets:read"
|
|
702
|
+
* ],
|
|
703
|
+
* "datasets": [
|
|
704
|
+
* {
|
|
705
|
+
* "params": "dataset_id"
|
|
706
|
+
* }
|
|
707
|
+
* ]
|
|
708
|
+
* }
|
|
709
|
+
* ]
|
|
710
|
+
*/
|
|
183
711
|
post: operations["ListClusterFacets"];
|
|
184
712
|
};
|
|
185
713
|
"/datasets/{dataset_id}/cluster/centroids/list_closest_to_center": {
|
|
186
|
-
/**
|
|
714
|
+
/**
|
|
715
|
+
* List documents with vector fields closest to centroids.
|
|
716
|
+
*
|
|
717
|
+
* ### Required permissions
|
|
718
|
+
* > [
|
|
719
|
+
* {
|
|
720
|
+
* "actions": [
|
|
721
|
+
* "datasets:read"
|
|
722
|
+
* ],
|
|
723
|
+
* "datasets": [
|
|
724
|
+
* {
|
|
725
|
+
* "params": "dataset_id"
|
|
726
|
+
* }
|
|
727
|
+
* ]
|
|
728
|
+
* }
|
|
729
|
+
* ]
|
|
730
|
+
*/
|
|
187
731
|
post: operations["ListClosestToCentroids"];
|
|
188
732
|
};
|
|
189
733
|
"/datasets/{dataset_id}/cluster/centroids/list_furthest_from_center": {
|
|
190
|
-
/**
|
|
734
|
+
/**
|
|
735
|
+
* List documents with vector fields furthest from centroids.
|
|
736
|
+
*
|
|
737
|
+
* ### Required permissions
|
|
738
|
+
* > [
|
|
739
|
+
* {
|
|
740
|
+
* "actions": [
|
|
741
|
+
* "datasets:read"
|
|
742
|
+
* ],
|
|
743
|
+
* "datasets": [
|
|
744
|
+
* {
|
|
745
|
+
* "params": "dataset_id"
|
|
746
|
+
* }
|
|
747
|
+
* ]
|
|
748
|
+
* }
|
|
749
|
+
* ]
|
|
750
|
+
*/
|
|
191
751
|
post: operations["ListFurthestFromCentroids"];
|
|
192
752
|
};
|
|
193
753
|
"/datasets/{dataset_id}/cluster/centroids/documents": {
|
|
194
|
-
/**
|
|
754
|
+
/**
|
|
755
|
+
* List centroids, optionally filtering by their ids.
|
|
756
|
+
*
|
|
757
|
+
* ### Required permissions
|
|
758
|
+
* > [
|
|
759
|
+
* {
|
|
760
|
+
* "actions": [
|
|
761
|
+
* "datasets:read"
|
|
762
|
+
* ],
|
|
763
|
+
* "datasets": [
|
|
764
|
+
* {
|
|
765
|
+
* "params": "dataset_id"
|
|
766
|
+
* }
|
|
767
|
+
* ]
|
|
768
|
+
* }
|
|
769
|
+
* ]
|
|
770
|
+
*/
|
|
195
771
|
post: operations["ListCentroids"];
|
|
196
772
|
};
|
|
197
773
|
"/datasets/{dataset_id}/cluster/centroids/configs/list": {
|
|
198
|
-
/**
|
|
774
|
+
/**
|
|
775
|
+
* List centroids configs for a dataset.
|
|
776
|
+
*
|
|
777
|
+
* ### Required permissions
|
|
778
|
+
* > [
|
|
779
|
+
* {
|
|
780
|
+
* "actions": [
|
|
781
|
+
* "datasets:read"
|
|
782
|
+
* ],
|
|
783
|
+
* "datasets": [
|
|
784
|
+
* {
|
|
785
|
+
* "params": "dataset_id"
|
|
786
|
+
* }
|
|
787
|
+
* ]
|
|
788
|
+
* }
|
|
789
|
+
* ]
|
|
790
|
+
*/
|
|
199
791
|
get: operations["ListCentroidConfigs"];
|
|
200
792
|
};
|
|
201
793
|
"/datasets/{dataset_id}/cluster/centroids/{centroid_id}/delete": {
|
|
202
|
-
/**
|
|
794
|
+
/**
|
|
795
|
+
* Delete a centroid by ID
|
|
796
|
+
*
|
|
797
|
+
* ### Required permissions
|
|
798
|
+
* > [
|
|
799
|
+
* {
|
|
800
|
+
* "actions": [
|
|
801
|
+
* "datasets:write"
|
|
802
|
+
* ],
|
|
803
|
+
* "datasets": [
|
|
804
|
+
* {
|
|
805
|
+
* "params": "dataset_id"
|
|
806
|
+
* }
|
|
807
|
+
* ]
|
|
808
|
+
* }
|
|
809
|
+
* ]
|
|
810
|
+
*/
|
|
203
811
|
post: operations["DeleteCentroid"];
|
|
204
812
|
};
|
|
205
813
|
"/datasets/{dataset_id}/cluster/realtime": {
|
|
814
|
+
/**
|
|
815
|
+
* ### Required permissions
|
|
816
|
+
* > [
|
|
817
|
+
* {
|
|
818
|
+
* "actions": [
|
|
819
|
+
* "datasets:read"
|
|
820
|
+
* ],
|
|
821
|
+
* "datasets": [
|
|
822
|
+
* {
|
|
823
|
+
* "body": "dataset_id"
|
|
824
|
+
* }
|
|
825
|
+
* ]
|
|
826
|
+
* }
|
|
827
|
+
* ]
|
|
828
|
+
*/
|
|
206
829
|
post: operations["RealtimeClustering"];
|
|
207
830
|
};
|
|
208
831
|
"/datasets/{dataset_id}/cluster/merge": {
|
|
832
|
+
/**
|
|
833
|
+
* ### Required permissions
|
|
834
|
+
* > [
|
|
835
|
+
* {
|
|
836
|
+
* "actions": [
|
|
837
|
+
* "datasets:write"
|
|
838
|
+
* ],
|
|
839
|
+
* "datasets": [
|
|
840
|
+
* {
|
|
841
|
+
* "params": "dataset_id"
|
|
842
|
+
* }
|
|
843
|
+
* ]
|
|
844
|
+
* }
|
|
845
|
+
* ]
|
|
846
|
+
*/
|
|
209
847
|
post: operations["MergeClusters"];
|
|
210
848
|
};
|
|
211
849
|
"/datasets/{dataset_id}/cluster/centroids/summaries/create": {
|
|
850
|
+
/**
|
|
851
|
+
* ### Required permissions
|
|
852
|
+
* > [
|
|
853
|
+
* {
|
|
854
|
+
* "actions": [
|
|
855
|
+
* "datasets:read",
|
|
856
|
+
* "datasets:write"
|
|
857
|
+
* ],
|
|
858
|
+
* "datasets": [
|
|
859
|
+
* {
|
|
860
|
+
* "params": "dataset_id"
|
|
861
|
+
* }
|
|
862
|
+
* ]
|
|
863
|
+
* }
|
|
864
|
+
* ]
|
|
865
|
+
*/
|
|
212
866
|
post: operations["CreateClusterSummaries"];
|
|
213
867
|
};
|
|
214
868
|
"/datasets/{dataset_id}/cluster/centroids/summaries/list": {
|
|
869
|
+
/**
|
|
870
|
+
* ### Required permissions
|
|
871
|
+
* > [
|
|
872
|
+
* {
|
|
873
|
+
* "actions": [
|
|
874
|
+
* "datasets:read"
|
|
875
|
+
* ],
|
|
876
|
+
* "datasets": [
|
|
877
|
+
* {
|
|
878
|
+
* "params": "dataset_id"
|
|
879
|
+
* }
|
|
880
|
+
* ]
|
|
881
|
+
* }
|
|
882
|
+
* ]
|
|
883
|
+
*/
|
|
215
884
|
post: operations["ListClusterSummaries"];
|
|
216
885
|
};
|
|
217
886
|
"/datasets/{dataset_id}/cluster/centroids/summaries/bulk_delete": {
|
|
887
|
+
/**
|
|
888
|
+
* ### Required permissions
|
|
889
|
+
* > [
|
|
890
|
+
* {
|
|
891
|
+
* "actions": [
|
|
892
|
+
* "datasets:write"
|
|
893
|
+
* ],
|
|
894
|
+
* "datasets": [
|
|
895
|
+
* {
|
|
896
|
+
* "params": "dataset_id"
|
|
897
|
+
* }
|
|
898
|
+
* ]
|
|
899
|
+
* }
|
|
900
|
+
* ]
|
|
901
|
+
*/
|
|
218
902
|
post: operations["DeleteClusterSummaries"];
|
|
219
903
|
};
|
|
220
904
|
"/organizations/create": {
|
|
905
|
+
/**
|
|
906
|
+
* ### Required permissions
|
|
907
|
+
* > []
|
|
908
|
+
*/
|
|
221
909
|
post: operations["CreateOrganization"];
|
|
222
910
|
};
|
|
223
911
|
"/organizations/{organization_id}/update": {
|
|
912
|
+
/**
|
|
913
|
+
* ### Required permissions
|
|
914
|
+
* > [
|
|
915
|
+
* {
|
|
916
|
+
* "actions": [
|
|
917
|
+
* "organizations:write"
|
|
918
|
+
* ],
|
|
919
|
+
* "organizations": [
|
|
920
|
+
* {
|
|
921
|
+
* "params": "organization_id"
|
|
922
|
+
* }
|
|
923
|
+
* ]
|
|
924
|
+
* }
|
|
925
|
+
* ]
|
|
926
|
+
*/
|
|
224
927
|
post: operations["UpdateOrganization"];
|
|
225
928
|
};
|
|
226
929
|
"/admin/organizations/{organization_id}/update": {
|
|
930
|
+
/**
|
|
931
|
+
* ### Required permissions
|
|
932
|
+
* > [
|
|
933
|
+
* {
|
|
934
|
+
* "actions": [
|
|
935
|
+
* "support:write"
|
|
936
|
+
* ],
|
|
937
|
+
* "organizations": [
|
|
938
|
+
* {
|
|
939
|
+
* "params": "organization_id"
|
|
940
|
+
* }
|
|
941
|
+
* ]
|
|
942
|
+
* }
|
|
943
|
+
* ]
|
|
944
|
+
*/
|
|
227
945
|
post: operations["UpdateOrganizationAdmin"];
|
|
228
946
|
};
|
|
229
947
|
"/organizations/list": {
|
|
230
|
-
/**
|
|
948
|
+
/**
|
|
949
|
+
* List all organizations and their metadata
|
|
950
|
+
*
|
|
951
|
+
* ### Required permissions
|
|
952
|
+
* > [
|
|
953
|
+
* {
|
|
954
|
+
* "actions": [
|
|
955
|
+
* "organizations:read"
|
|
956
|
+
* ]
|
|
957
|
+
* }
|
|
958
|
+
* ]
|
|
959
|
+
*/
|
|
231
960
|
get: operations["ListOrganizations"];
|
|
232
961
|
};
|
|
233
962
|
"/organizations/{organization_id}/delete": {
|
|
963
|
+
/**
|
|
964
|
+
* ### Required permissions
|
|
965
|
+
* > [
|
|
966
|
+
* {
|
|
967
|
+
* "actions": [
|
|
968
|
+
* "organizations:write"
|
|
969
|
+
* ],
|
|
970
|
+
* "organizations": [
|
|
971
|
+
* {
|
|
972
|
+
* "params": "organization_id"
|
|
973
|
+
* }
|
|
974
|
+
* ]
|
|
975
|
+
* }
|
|
976
|
+
* ]
|
|
977
|
+
*/
|
|
234
978
|
post: operations["DeleteOrganization"];
|
|
235
979
|
};
|
|
236
980
|
"/organizations/{organization_id}/get": {
|
|
981
|
+
/**
|
|
982
|
+
* ### Required permissions
|
|
983
|
+
* > [
|
|
984
|
+
* {
|
|
985
|
+
* "actions": [
|
|
986
|
+
* "organizations:read"
|
|
987
|
+
* ],
|
|
988
|
+
* "organizations": [
|
|
989
|
+
* {
|
|
990
|
+
* "params": "organization_id"
|
|
991
|
+
* }
|
|
992
|
+
* ]
|
|
993
|
+
* }
|
|
994
|
+
* ]
|
|
995
|
+
*/
|
|
237
996
|
get: operations["GetOrganization"];
|
|
238
997
|
};
|
|
239
998
|
"/organizations/{organization_id}/usage/get": {
|
|
999
|
+
/**
|
|
1000
|
+
* ### Required permissions
|
|
1001
|
+
* > [
|
|
1002
|
+
* {
|
|
1003
|
+
* "actions": [
|
|
1004
|
+
* "organizations:read"
|
|
1005
|
+
* ],
|
|
1006
|
+
* "organizations": [
|
|
1007
|
+
* {
|
|
1008
|
+
* "params": "organization_id"
|
|
1009
|
+
* }
|
|
1010
|
+
* ]
|
|
1011
|
+
* }
|
|
1012
|
+
* ]
|
|
1013
|
+
*/
|
|
240
1014
|
get: operations["GetOrganizationUsage"];
|
|
241
1015
|
};
|
|
242
1016
|
"/organizations/{organization_id}/users/list": {
|
|
1017
|
+
/**
|
|
1018
|
+
* ### Required permissions
|
|
1019
|
+
* > [
|
|
1020
|
+
* {
|
|
1021
|
+
* "actions": [
|
|
1022
|
+
* "organizations:read"
|
|
1023
|
+
* ],
|
|
1024
|
+
* "organizations": [
|
|
1025
|
+
* {
|
|
1026
|
+
* "params": "organization_id"
|
|
1027
|
+
* }
|
|
1028
|
+
* ]
|
|
1029
|
+
* }
|
|
1030
|
+
* ]
|
|
1031
|
+
*/
|
|
243
1032
|
get: operations["ListUsersInOrganization"];
|
|
244
1033
|
};
|
|
245
1034
|
"/organizations/{organization_id}/projects/list": {
|
|
1035
|
+
/**
|
|
1036
|
+
* ### Required permissions
|
|
1037
|
+
* > [
|
|
1038
|
+
* {
|
|
1039
|
+
* "actions": [
|
|
1040
|
+
* "organizations:read"
|
|
1041
|
+
* ],
|
|
1042
|
+
* "organizations": [
|
|
1043
|
+
* {
|
|
1044
|
+
* "params": "organization_id"
|
|
1045
|
+
* }
|
|
1046
|
+
* ]
|
|
1047
|
+
* }
|
|
1048
|
+
* ]
|
|
1049
|
+
*/
|
|
246
1050
|
get: operations["ListProjectsInOrganization"];
|
|
247
1051
|
};
|
|
248
1052
|
"/datasets/{dataset_id}/documents/insert": {
|
|
@@ -255,6 +1059,21 @@ export interface paths {
|
|
|
255
1059
|
*
|
|
256
1060
|
* If inserting many items in a short timespan, use bulkInsert, or set update_schema to false.
|
|
257
1061
|
* Every insert api call temporarily locks and updates the schema, so will slow down with many inserts in quick succession.
|
|
1062
|
+
*
|
|
1063
|
+
*
|
|
1064
|
+
* ### Required permissions
|
|
1065
|
+
* > [
|
|
1066
|
+
* {
|
|
1067
|
+
* "actions": [
|
|
1068
|
+
* "datasets:write"
|
|
1069
|
+
* ],
|
|
1070
|
+
* "datasets": [
|
|
1071
|
+
* {
|
|
1072
|
+
* "params": "dataset_id"
|
|
1073
|
+
* }
|
|
1074
|
+
* ]
|
|
1075
|
+
* }
|
|
1076
|
+
* ]
|
|
258
1077
|
*/
|
|
259
1078
|
post: operations["Insert"];
|
|
260
1079
|
};
|
|
@@ -272,31 +1091,132 @@ export interface paths {
|
|
|
272
1091
|
* If the provided dataset doesn't exist, one will be automatically created.
|
|
273
1092
|
*
|
|
274
1093
|
* Limit the payload of documents to a maximum 100MB for optimal performance.
|
|
1094
|
+
*
|
|
1095
|
+
*
|
|
1096
|
+
* ### Required permissions
|
|
1097
|
+
* > [
|
|
1098
|
+
* {
|
|
1099
|
+
* "actions": [
|
|
1100
|
+
* "datasets:write"
|
|
1101
|
+
* ],
|
|
1102
|
+
* "datasets": [
|
|
1103
|
+
* {
|
|
1104
|
+
* "params": "dataset_id"
|
|
1105
|
+
* }
|
|
1106
|
+
* ]
|
|
1107
|
+
* }
|
|
1108
|
+
* ]
|
|
275
1109
|
*/
|
|
276
1110
|
post: operations["BulkInsert"];
|
|
277
1111
|
};
|
|
278
1112
|
"/datasets/{dataset_id}/get_file_upload_urls": {
|
|
279
|
-
/**
|
|
1113
|
+
/**
|
|
1114
|
+
* specify a list of file paths. For each file path, a url upload_url is returned. files can be POSTed on upload_url to upload them. They can then be accessed on url. Upon dataset deletion, these files will be deleted.
|
|
1115
|
+
*
|
|
1116
|
+
* ### Required permissions
|
|
1117
|
+
* > [
|
|
1118
|
+
* {
|
|
1119
|
+
* "actions": [
|
|
1120
|
+
* "datasets:write"
|
|
1121
|
+
* ],
|
|
1122
|
+
* "datasets": [
|
|
1123
|
+
* {
|
|
1124
|
+
* "params": "dataset_id"
|
|
1125
|
+
* }
|
|
1126
|
+
* ]
|
|
1127
|
+
* }
|
|
1128
|
+
* ]
|
|
1129
|
+
*/
|
|
280
1130
|
post: operations["GetFileUploadUrlsForDataset"];
|
|
281
1131
|
};
|
|
282
1132
|
"/datasets/{dataset_id}/list_file_uploads": {
|
|
283
|
-
/**
|
|
1133
|
+
/**
|
|
1134
|
+
* Return up to 1000 files uploaded for a dataset.
|
|
1135
|
+
*
|
|
1136
|
+
* ### Required permissions
|
|
1137
|
+
* > [
|
|
1138
|
+
* {
|
|
1139
|
+
* "actions": [
|
|
1140
|
+
* "datasets:read"
|
|
1141
|
+
* ],
|
|
1142
|
+
* "datasets": [
|
|
1143
|
+
* {
|
|
1144
|
+
* "params": "dataset_id"
|
|
1145
|
+
* }
|
|
1146
|
+
* ]
|
|
1147
|
+
* }
|
|
1148
|
+
* ]
|
|
1149
|
+
*/
|
|
284
1150
|
get: operations["ListFileUploadsForDataset"];
|
|
285
1151
|
};
|
|
286
1152
|
"/datasets/{dataset_id}/parse_blob": {
|
|
287
|
-
/**
|
|
1153
|
+
/**
|
|
1154
|
+
* Bulk insert a large number of documents by downloading a file using "download url". This bypasses the need to directly send documents to the api, as happens in BulkInsert.
|
|
1155
|
+
*
|
|
1156
|
+
* ### Required permissions
|
|
1157
|
+
* > [
|
|
1158
|
+
* {
|
|
1159
|
+
* "actions": [
|
|
1160
|
+
* "datasets:write"
|
|
1161
|
+
* ],
|
|
1162
|
+
* "datasets": [
|
|
1163
|
+
* {
|
|
1164
|
+
* "params": "dataset_id"
|
|
1165
|
+
* }
|
|
1166
|
+
* ]
|
|
1167
|
+
* }
|
|
1168
|
+
* ]
|
|
1169
|
+
*/
|
|
288
1170
|
post: operations["ParseBlob"];
|
|
289
1171
|
};
|
|
290
1172
|
"/admin/copy_foreign_dataset": {
|
|
291
|
-
/**
|
|
1173
|
+
/**
|
|
1174
|
+
* Copy a dataset from another users projects into your project. This is considered a project job.
|
|
1175
|
+
*
|
|
1176
|
+
* ### Required permissions
|
|
1177
|
+
* > []
|
|
1178
|
+
*/
|
|
292
1179
|
post: operations["CopyForeignDataset"];
|
|
293
1180
|
};
|
|
294
1181
|
"/admin/request_read_api_key": {
|
|
295
|
-
/**
|
|
1182
|
+
/**
|
|
1183
|
+
* Creates a read only key for your project. Make sure to save the api key somewhere safe. When doing a search the admin username should still be used.
|
|
1184
|
+
*
|
|
1185
|
+
* ### Required permissions
|
|
1186
|
+
* > [
|
|
1187
|
+
* {
|
|
1188
|
+
* "actions": [
|
|
1189
|
+
* "users:write",
|
|
1190
|
+
* "datasets:read"
|
|
1191
|
+
* ],
|
|
1192
|
+
* "datasets": [
|
|
1193
|
+
* {
|
|
1194
|
+
* "raw": "*"
|
|
1195
|
+
* }
|
|
1196
|
+
* ]
|
|
1197
|
+
* }
|
|
1198
|
+
* ]
|
|
1199
|
+
*/
|
|
296
1200
|
post: operations["CreateProjectReadKey"];
|
|
297
1201
|
};
|
|
298
1202
|
"/datasets/{dataset_id}/delete": {
|
|
299
|
-
/**
|
|
1203
|
+
/**
|
|
1204
|
+
* Delete a dataset.
|
|
1205
|
+
*
|
|
1206
|
+
* ### Required permissions
|
|
1207
|
+
* > [
|
|
1208
|
+
* {
|
|
1209
|
+
* "actions": [
|
|
1210
|
+
* "datasets:write"
|
|
1211
|
+
* ],
|
|
1212
|
+
* "datasets": [
|
|
1213
|
+
* {
|
|
1214
|
+
* "params": "dataset_id"
|
|
1215
|
+
* }
|
|
1216
|
+
* ]
|
|
1217
|
+
* }
|
|
1218
|
+
* ]
|
|
1219
|
+
*/
|
|
300
1220
|
post: operations["DeleteDataset"];
|
|
301
1221
|
};
|
|
302
1222
|
"/datasets/create": {
|
|
@@ -334,40 +1254,183 @@ export interface paths {
|
|
|
334
1254
|
*
|
|
335
1255
|
* For more information about vectors check out the 'Vectorizing' section, **\/services/search/vector** or out blog at [https://relevance.ai/blog](https://relevance.ai/blog).
|
|
336
1256
|
* For more information about chunks and chunk vectors check out **\/services/search/chunk**.
|
|
1257
|
+
*
|
|
1258
|
+
*
|
|
1259
|
+
*
|
|
1260
|
+
*
|
|
1261
|
+
* ### Required permissions
|
|
1262
|
+
* > [
|
|
1263
|
+
* {
|
|
1264
|
+
* "actions": [
|
|
1265
|
+
* "datasets:write"
|
|
1266
|
+
* ],
|
|
1267
|
+
* "datasets": [
|
|
1268
|
+
* {
|
|
1269
|
+
* "body": "id"
|
|
1270
|
+
* }
|
|
1271
|
+
* ]
|
|
1272
|
+
* }
|
|
1273
|
+
* ]
|
|
337
1274
|
*/
|
|
338
1275
|
post: operations["CreateDataset"];
|
|
339
1276
|
};
|
|
340
1277
|
"/datasets/{dataset_id}/schema": {
|
|
1278
|
+
/**
|
|
1279
|
+
* ### Required permissions
|
|
1280
|
+
* > [
|
|
1281
|
+
* {
|
|
1282
|
+
* "actions": [
|
|
1283
|
+
* "datasets:read"
|
|
1284
|
+
* ],
|
|
1285
|
+
* "datasets": [
|
|
1286
|
+
* {
|
|
1287
|
+
* "params": "dataset_id"
|
|
1288
|
+
* }
|
|
1289
|
+
* ]
|
|
1290
|
+
* }
|
|
1291
|
+
* ]
|
|
1292
|
+
*/
|
|
341
1293
|
get: operations["GetSchema"];
|
|
342
1294
|
};
|
|
343
1295
|
"/datasets/list": {
|
|
344
|
-
/**
|
|
1296
|
+
/**
|
|
1297
|
+
* List all datasets in a project that you are authorized to read/write.
|
|
1298
|
+
*
|
|
1299
|
+
* ### Required permissions
|
|
1300
|
+
* > [
|
|
1301
|
+
* {
|
|
1302
|
+
* "actions": []
|
|
1303
|
+
* }
|
|
1304
|
+
* ]
|
|
1305
|
+
*/
|
|
345
1306
|
get: operations["ListDatasets"];
|
|
346
1307
|
};
|
|
347
1308
|
"/datasets/combine": {
|
|
1309
|
+
/**
|
|
1310
|
+
* ### Required permissions
|
|
1311
|
+
* > [
|
|
1312
|
+
* {
|
|
1313
|
+
* "actions": [
|
|
1314
|
+
* "datasets:read"
|
|
1315
|
+
* ],
|
|
1316
|
+
* "datasets": [
|
|
1317
|
+
* {
|
|
1318
|
+
* "body": "dataset_ids"
|
|
1319
|
+
* }
|
|
1320
|
+
* ]
|
|
1321
|
+
* },
|
|
1322
|
+
* {
|
|
1323
|
+
* "actions": [
|
|
1324
|
+
* "datasets:write"
|
|
1325
|
+
* ],
|
|
1326
|
+
* "datasets": [
|
|
1327
|
+
* {
|
|
1328
|
+
* "body": "new_dataset_id"
|
|
1329
|
+
* }
|
|
1330
|
+
* ]
|
|
1331
|
+
* }
|
|
1332
|
+
* ]
|
|
1333
|
+
*/
|
|
348
1334
|
post: operations["CombineDatasets"];
|
|
349
1335
|
};
|
|
350
1336
|
"/datasets/combine/{job_id}/get": {
|
|
1337
|
+
/**
|
|
1338
|
+
* ### Required permissions
|
|
1339
|
+
* > []
|
|
1340
|
+
*/
|
|
351
1341
|
post: operations["GetCombineJobStatus"];
|
|
352
1342
|
};
|
|
353
1343
|
"/datasets/search": {
|
|
354
|
-
/**
|
|
1344
|
+
/**
|
|
1345
|
+
* Search all datasets in a project that you are authorized to read/write.
|
|
1346
|
+
*
|
|
1347
|
+
* ### Required permissions
|
|
1348
|
+
* > [
|
|
1349
|
+
* {
|
|
1350
|
+
* "actions": []
|
|
1351
|
+
* }
|
|
1352
|
+
* ]
|
|
1353
|
+
*/
|
|
355
1354
|
get: operations["SearchDatasets"];
|
|
356
1355
|
};
|
|
357
1356
|
"/datasets/{dataset_id}/monitor/health": {
|
|
358
|
-
/**
|
|
1357
|
+
/**
|
|
1358
|
+
* Gives you a summary of the health of your vectors, e.g. how many documents with vectors are missing, how many documents with zero vectors
|
|
1359
|
+
*
|
|
1360
|
+
* ### Required permissions
|
|
1361
|
+
* > [
|
|
1362
|
+
* {
|
|
1363
|
+
* "actions": [
|
|
1364
|
+
* "datasets:read"
|
|
1365
|
+
* ],
|
|
1366
|
+
* "datasets": [
|
|
1367
|
+
* {
|
|
1368
|
+
* "params": "dataset_id"
|
|
1369
|
+
* }
|
|
1370
|
+
* ]
|
|
1371
|
+
* }
|
|
1372
|
+
* ]
|
|
1373
|
+
*/
|
|
359
1374
|
get: operations["GetFieldHealth"];
|
|
360
1375
|
};
|
|
361
1376
|
"/datasets/{dataset_id}/monitor/stats": {
|
|
362
|
-
/**
|
|
1377
|
+
/**
|
|
1378
|
+
* View the usage statistics of a dataset.
|
|
1379
|
+
*
|
|
1380
|
+
* ### Required permissions
|
|
1381
|
+
* > [
|
|
1382
|
+
* {
|
|
1383
|
+
* "actions": [
|
|
1384
|
+
* "datasets:read"
|
|
1385
|
+
* ],
|
|
1386
|
+
* "datasets": [
|
|
1387
|
+
* {
|
|
1388
|
+
* "params": "dataset_id"
|
|
1389
|
+
* }
|
|
1390
|
+
* ]
|
|
1391
|
+
* }
|
|
1392
|
+
* ]
|
|
1393
|
+
*/
|
|
363
1394
|
get: operations["GetDatasetStats"];
|
|
364
1395
|
};
|
|
365
1396
|
"/datasets/{dataset_id}/monitor/usage": {
|
|
366
|
-
/**
|
|
1397
|
+
/**
|
|
1398
|
+
* View api call usage statistics for a dataset.
|
|
1399
|
+
*
|
|
1400
|
+
* ### Required permissions
|
|
1401
|
+
* > [
|
|
1402
|
+
* {
|
|
1403
|
+
* "actions": [
|
|
1404
|
+
* "datasets:read"
|
|
1405
|
+
* ],
|
|
1406
|
+
* "datasets": [
|
|
1407
|
+
* {
|
|
1408
|
+
* "params": "dataset_id"
|
|
1409
|
+
* }
|
|
1410
|
+
* ]
|
|
1411
|
+
* }
|
|
1412
|
+
* ]
|
|
1413
|
+
*/
|
|
367
1414
|
post: operations["GetDatasetUsage"];
|
|
368
1415
|
};
|
|
369
1416
|
"/datasets/{dataset_id}/vector_mappings": {
|
|
370
|
-
/**
|
|
1417
|
+
/**
|
|
1418
|
+
* DEPRECATED !!!! Retrieve the mapping of vectors generated through fields, dictionary, array, etc
|
|
1419
|
+
*
|
|
1420
|
+
* ### Required permissions
|
|
1421
|
+
* > [
|
|
1422
|
+
* {
|
|
1423
|
+
* "actions": [
|
|
1424
|
+
* "datasets:read"
|
|
1425
|
+
* ],
|
|
1426
|
+
* "datasets": [
|
|
1427
|
+
* {
|
|
1428
|
+
* "params": "dataset_id"
|
|
1429
|
+
* }
|
|
1430
|
+
* ]
|
|
1431
|
+
* }
|
|
1432
|
+
* ]
|
|
1433
|
+
*/
|
|
371
1434
|
get: operations["GetVectorMappings"];
|
|
372
1435
|
};
|
|
373
1436
|
"/datasets/{dataset_id}/details": {
|
|
@@ -382,6 +1445,21 @@ export interface paths {
|
|
|
382
1445
|
* | vector_health | Number of zero vectors stored. (returns same data as **\/dataset/{dataset_id}/monitor/health**) |
|
|
383
1446
|
* | schema_stats | Fields and number of documents missing/not missing for that field. (returns same data as **\/dataset/{dataset_id}/monitor/stats**) |
|
|
384
1447
|
* | active_jobs | All active jobs/tasks on the dataset. (returns same data as **\/dataset/{dataset_id}/tasks/list**) |
|
|
1448
|
+
*
|
|
1449
|
+
*
|
|
1450
|
+
* ### Required permissions
|
|
1451
|
+
* > [
|
|
1452
|
+
* {
|
|
1453
|
+
* "actions": [
|
|
1454
|
+
* "datasets:read"
|
|
1455
|
+
* ],
|
|
1456
|
+
* "datasets": [
|
|
1457
|
+
* {
|
|
1458
|
+
* "params": "dataset_id"
|
|
1459
|
+
* }
|
|
1460
|
+
* ]
|
|
1461
|
+
* }
|
|
1462
|
+
* ]
|
|
385
1463
|
*/
|
|
386
1464
|
post: operations["GetDatasetDetails"];
|
|
387
1465
|
};
|
|
@@ -390,6 +1468,21 @@ export interface paths {
|
|
|
390
1468
|
* Retrieve a document by its `_id`.
|
|
391
1469
|
*
|
|
392
1470
|
* This is the most performant method to get a document or check if it exists, faster than filtering a dataset for by an `_id`.
|
|
1471
|
+
*
|
|
1472
|
+
*
|
|
1473
|
+
* ### Required permissions
|
|
1474
|
+
* > [
|
|
1475
|
+
* {
|
|
1476
|
+
* "actions": [
|
|
1477
|
+
* "datasets:read"
|
|
1478
|
+
* ],
|
|
1479
|
+
* "datasets": [
|
|
1480
|
+
* {
|
|
1481
|
+
* "params": "dataset_id"
|
|
1482
|
+
* }
|
|
1483
|
+
* ]
|
|
1484
|
+
* }
|
|
1485
|
+
* ]
|
|
393
1486
|
*/
|
|
394
1487
|
get: operations["GetDocument"];
|
|
395
1488
|
};
|
|
@@ -398,19 +1491,98 @@ export interface paths {
|
|
|
398
1491
|
* Delete a document by its `_id` and remove it from the dataset.
|
|
399
1492
|
*
|
|
400
1493
|
* Support for deleting many documents at once is available through [`/bulk_delete`](/reference/bulk_delete_api_datasets__dataset_id__documents_bulk_delete_post).
|
|
1494
|
+
*
|
|
1495
|
+
*
|
|
1496
|
+
* ### Required permissions
|
|
1497
|
+
* > [
|
|
1498
|
+
* {
|
|
1499
|
+
* "actions": [
|
|
1500
|
+
* "datasets:write"
|
|
1501
|
+
* ],
|
|
1502
|
+
* "datasets": [
|
|
1503
|
+
* {
|
|
1504
|
+
* "params": "dataset_id"
|
|
1505
|
+
* }
|
|
1506
|
+
* ]
|
|
1507
|
+
* }
|
|
1508
|
+
* ]
|
|
401
1509
|
*/
|
|
402
1510
|
post: operations["DeleteDocument"];
|
|
403
1511
|
};
|
|
404
1512
|
"/datasets/{dataset_id}/settings": {
|
|
405
|
-
/**
|
|
1513
|
+
/**
|
|
1514
|
+
* Retreives settings for dataset.
|
|
1515
|
+
*
|
|
1516
|
+
* ### Required permissions
|
|
1517
|
+
* > [
|
|
1518
|
+
* {
|
|
1519
|
+
* "actions": [
|
|
1520
|
+
* "datasets:read"
|
|
1521
|
+
* ],
|
|
1522
|
+
* "datasets": [
|
|
1523
|
+
* {
|
|
1524
|
+
* "params": "dataset_id"
|
|
1525
|
+
* }
|
|
1526
|
+
* ]
|
|
1527
|
+
* }
|
|
1528
|
+
* ]
|
|
1529
|
+
*/
|
|
406
1530
|
get: operations["GetDatasetSettings"];
|
|
407
|
-
/**
|
|
1531
|
+
/**
|
|
1532
|
+
* Add and overwrite settings about a dataset. Notably description, data source, etc.
|
|
1533
|
+
*
|
|
1534
|
+
* ### Required permissions
|
|
1535
|
+
* > [
|
|
1536
|
+
* {
|
|
1537
|
+
* "actions": [
|
|
1538
|
+
* "datasets:write"
|
|
1539
|
+
* ],
|
|
1540
|
+
* "datasets": [
|
|
1541
|
+
* {
|
|
1542
|
+
* "params": "dataset_id"
|
|
1543
|
+
* }
|
|
1544
|
+
* ]
|
|
1545
|
+
* }
|
|
1546
|
+
* ]
|
|
1547
|
+
*/
|
|
408
1548
|
post: operations["UpsertDatasetSettings"];
|
|
409
1549
|
};
|
|
410
1550
|
"/datasets/{dataset_id}/metadata": {
|
|
411
|
-
/**
|
|
1551
|
+
/**
|
|
1552
|
+
* Retreives metadata about a dataset. Notably description, data source, etc
|
|
1553
|
+
*
|
|
1554
|
+
* ### Required permissions
|
|
1555
|
+
* > [
|
|
1556
|
+
* {
|
|
1557
|
+
* "actions": [
|
|
1558
|
+
* "datasets:read"
|
|
1559
|
+
* ],
|
|
1560
|
+
* "datasets": [
|
|
1561
|
+
* {
|
|
1562
|
+
* "params": "dataset_id"
|
|
1563
|
+
* }
|
|
1564
|
+
* ]
|
|
1565
|
+
* }
|
|
1566
|
+
* ]
|
|
1567
|
+
*/
|
|
412
1568
|
get: operations["GetDatasetMetadata"];
|
|
413
|
-
/**
|
|
1569
|
+
/**
|
|
1570
|
+
* Retreives metadata about a dataset. Notably description, data source, etc
|
|
1571
|
+
*
|
|
1572
|
+
* ### Required permissions
|
|
1573
|
+
* > [
|
|
1574
|
+
* {
|
|
1575
|
+
* "actions": [
|
|
1576
|
+
* "datasets:write"
|
|
1577
|
+
* ],
|
|
1578
|
+
* "datasets": [
|
|
1579
|
+
* {
|
|
1580
|
+
* "params": "dataset_id"
|
|
1581
|
+
* }
|
|
1582
|
+
* ]
|
|
1583
|
+
* }
|
|
1584
|
+
* ]
|
|
1585
|
+
*/
|
|
414
1586
|
post: operations["UpsertDatasetMetadata"];
|
|
415
1587
|
};
|
|
416
1588
|
"/datasets/{dataset_id}/documents/update": {
|
|
@@ -422,11 +1594,42 @@ export interface paths {
|
|
|
422
1594
|
* If the provided `_id` has no matching document in the dataset, a new document will be created. Likewise, if the provided `dataset_id` does not match a dataset in your project a new one will be created.
|
|
423
1595
|
*
|
|
424
1596
|
* Support for updating many documents at once with a filter condition is available through [`/update_where`](/reference/updatewhere).
|
|
1597
|
+
*
|
|
1598
|
+
*
|
|
1599
|
+
* ### Required permissions
|
|
1600
|
+
* > [
|
|
1601
|
+
* {
|
|
1602
|
+
* "actions": [
|
|
1603
|
+
* "datasets:write"
|
|
1604
|
+
* ],
|
|
1605
|
+
* "datasets": [
|
|
1606
|
+
* {
|
|
1607
|
+
* "params": "dataset_id"
|
|
1608
|
+
* }
|
|
1609
|
+
* ]
|
|
1610
|
+
* }
|
|
1611
|
+
* ]
|
|
425
1612
|
*/
|
|
426
1613
|
post: operations["Update"];
|
|
427
1614
|
};
|
|
428
1615
|
"/datasets/{dataset_id}/documents/delete_fields": {
|
|
429
|
-
/**
|
|
1616
|
+
/**
|
|
1617
|
+
* Delete fields in a document in a dataset by its id.
|
|
1618
|
+
*
|
|
1619
|
+
* ### Required permissions
|
|
1620
|
+
* > [
|
|
1621
|
+
* {
|
|
1622
|
+
* "actions": [
|
|
1623
|
+
* "datasets:write"
|
|
1624
|
+
* ],
|
|
1625
|
+
* "datasets": [
|
|
1626
|
+
* {
|
|
1627
|
+
* "params": "dataset_id"
|
|
1628
|
+
* }
|
|
1629
|
+
* ]
|
|
1630
|
+
* }
|
|
1631
|
+
* ]
|
|
1632
|
+
*/
|
|
430
1633
|
post: operations["DeleteDocumentFields"];
|
|
431
1634
|
};
|
|
432
1635
|
"/datasets/{dataset_id}/documents/bulk_update": {
|
|
@@ -436,6 +1639,21 @@ export interface paths {
|
|
|
436
1639
|
* If updating many items in a short timespan, please use BulkUpdate.
|
|
437
1640
|
*
|
|
438
1641
|
* Every update api call temporarily locks and updates the schema, so will slow down with many updates in quick succession.
|
|
1642
|
+
*
|
|
1643
|
+
*
|
|
1644
|
+
* ### Required permissions
|
|
1645
|
+
* > [
|
|
1646
|
+
* {
|
|
1647
|
+
* "actions": [
|
|
1648
|
+
* "datasets:write"
|
|
1649
|
+
* ],
|
|
1650
|
+
* "datasets": [
|
|
1651
|
+
* {
|
|
1652
|
+
* "params": "dataset_id"
|
|
1653
|
+
* }
|
|
1654
|
+
* ]
|
|
1655
|
+
* }
|
|
1656
|
+
* ]
|
|
439
1657
|
*/
|
|
440
1658
|
post: operations["BulkUpdate"];
|
|
441
1659
|
};
|
|
@@ -446,11 +1664,42 @@ export interface paths {
|
|
|
446
1664
|
* This method supports a partial update so you may add new fields or update only those you need. Other fields will remain unaffected.
|
|
447
1665
|
*
|
|
448
1666
|
* If the provided `dataset_id` does not match a dataset in your project, a new one will be created.
|
|
1667
|
+
*
|
|
1668
|
+
*
|
|
1669
|
+
* ### Required permissions
|
|
1670
|
+
* > [
|
|
1671
|
+
* {
|
|
1672
|
+
* "actions": [
|
|
1673
|
+
* "datasets:write"
|
|
1674
|
+
* ],
|
|
1675
|
+
* "datasets": [
|
|
1676
|
+
* {
|
|
1677
|
+
* "params": "dataset_id"
|
|
1678
|
+
* }
|
|
1679
|
+
* ]
|
|
1680
|
+
* }
|
|
1681
|
+
* ]
|
|
449
1682
|
*/
|
|
450
1683
|
post: operations["UpdateWhere"];
|
|
451
1684
|
};
|
|
452
1685
|
"/datasets/{dataset_id}/facets": {
|
|
453
|
-
/**
|
|
1686
|
+
/**
|
|
1687
|
+
* Takes a high level aggregation of every field, return their unique values and frequencies. This is used to help create the filter bar for search.
|
|
1688
|
+
*
|
|
1689
|
+
* ### Required permissions
|
|
1690
|
+
* > [
|
|
1691
|
+
* {
|
|
1692
|
+
* "actions": [
|
|
1693
|
+
* "datasets:read"
|
|
1694
|
+
* ],
|
|
1695
|
+
* "datasets": [
|
|
1696
|
+
* {
|
|
1697
|
+
* "params": "dataset_id"
|
|
1698
|
+
* }
|
|
1699
|
+
* ]
|
|
1700
|
+
* }
|
|
1701
|
+
* ]
|
|
1702
|
+
*/
|
|
454
1703
|
post: operations["ListFacets"];
|
|
455
1704
|
};
|
|
456
1705
|
"/datasets/{dataset_id}/documents/get_where": {
|
|
@@ -458,6 +1707,20 @@ export interface paths {
|
|
|
458
1707
|
* Retrieve documents with filters.
|
|
459
1708
|
* afterId is provided to retrieve even more documents. Loop through it to retrieve all documents in the database.
|
|
460
1709
|
* Filter is used to retrieve documents that match the conditions set in a filter query.
|
|
1710
|
+
*
|
|
1711
|
+
* ### Required permissions
|
|
1712
|
+
* > [
|
|
1713
|
+
* {
|
|
1714
|
+
* "actions": [
|
|
1715
|
+
* "datasets:read"
|
|
1716
|
+
* ],
|
|
1717
|
+
* "datasets": [
|
|
1718
|
+
* {
|
|
1719
|
+
* "params": "dataset_id"
|
|
1720
|
+
* }
|
|
1721
|
+
* ]
|
|
1722
|
+
* }
|
|
1723
|
+
* ]
|
|
461
1724
|
*/
|
|
462
1725
|
post: operations["GetWhere"];
|
|
463
1726
|
};
|
|
@@ -466,15 +1729,61 @@ export interface paths {
|
|
|
466
1729
|
* Retrieve documents with filters.
|
|
467
1730
|
* afterId is provided to retrieve even more documents. Loop through it to retrieve all documents in the database.
|
|
468
1731
|
* Filter is used to retrieve documents that match the conditions set in a filter query.
|
|
1732
|
+
*
|
|
1733
|
+
* ### Required permissions
|
|
1734
|
+
* > [
|
|
1735
|
+
* {
|
|
1736
|
+
* "actions": [
|
|
1737
|
+
* "datasets:read"
|
|
1738
|
+
* ],
|
|
1739
|
+
* "datasets": [
|
|
1740
|
+
* {
|
|
1741
|
+
* "params": "dataset_id"
|
|
1742
|
+
* }
|
|
1743
|
+
* ]
|
|
1744
|
+
* }
|
|
1745
|
+
* ]
|
|
469
1746
|
*/
|
|
470
1747
|
post: operations["PaginateDocuments"];
|
|
471
1748
|
};
|
|
472
1749
|
"/datasets/{dataset_id}/documents/bulk_get": {
|
|
473
|
-
/**
|
|
1750
|
+
/**
|
|
1751
|
+
* Retrieve documents by their IDs ("_id" field). This will retrieve the documents faster than a filter applied on the "_id" field. For single id lookup version of this request use /datasets/{dataset_id}/documents/get.
|
|
1752
|
+
*
|
|
1753
|
+
* ### Required permissions
|
|
1754
|
+
* > [
|
|
1755
|
+
* {
|
|
1756
|
+
* "actions": [
|
|
1757
|
+
* "datasets:read"
|
|
1758
|
+
* ],
|
|
1759
|
+
* "datasets": [
|
|
1760
|
+
* {
|
|
1761
|
+
* "params": "dataset_id"
|
|
1762
|
+
* }
|
|
1763
|
+
* ]
|
|
1764
|
+
* }
|
|
1765
|
+
* ]
|
|
1766
|
+
*/
|
|
474
1767
|
post: operations["BulkGetDocuments"];
|
|
475
1768
|
};
|
|
476
1769
|
"/datasets/{dataset_id}/documents/bulk_delete": {
|
|
477
|
-
/**
|
|
1770
|
+
/**
|
|
1771
|
+
* Delete a list of documents by their IDs. For deleting a single document refer to /datasets/{dataset_id}/documents/delete or deleting documents by filters refer to /datasets/{dataset_id}/documents/delete_where.
|
|
1772
|
+
*
|
|
1773
|
+
* ### Required permissions
|
|
1774
|
+
* > [
|
|
1775
|
+
* {
|
|
1776
|
+
* "actions": [
|
|
1777
|
+
* "datasets:write"
|
|
1778
|
+
* ],
|
|
1779
|
+
* "datasets": [
|
|
1780
|
+
* {
|
|
1781
|
+
* "params": "dataset_id"
|
|
1782
|
+
* }
|
|
1783
|
+
* ]
|
|
1784
|
+
* }
|
|
1785
|
+
* ]
|
|
1786
|
+
*/
|
|
478
1787
|
post: operations["BulkDeleteDocuments"];
|
|
479
1788
|
};
|
|
480
1789
|
"/datasets/{dataset_id}/documents/list": {
|
|
@@ -482,86 +1791,375 @@ export interface paths {
|
|
|
482
1791
|
* Retrieve documents with filters.
|
|
483
1792
|
* afterId is provided to retrieve even more documents. Loop through it to retrieve all documents in the database.
|
|
484
1793
|
* Filter is used to retrieve documents that match the conditions set in a filter query.
|
|
1794
|
+
*
|
|
1795
|
+
* ### Required permissions
|
|
1796
|
+
* > [
|
|
1797
|
+
* {
|
|
1798
|
+
* "actions": [
|
|
1799
|
+
* "datasets:read"
|
|
1800
|
+
* ],
|
|
1801
|
+
* "datasets": [
|
|
1802
|
+
* {
|
|
1803
|
+
* "params": "dataset_id"
|
|
1804
|
+
* }
|
|
1805
|
+
* ]
|
|
1806
|
+
* }
|
|
1807
|
+
* ]
|
|
485
1808
|
*/
|
|
486
1809
|
get: operations["ListDocuments"];
|
|
487
1810
|
};
|
|
488
1811
|
"/datasets/{dataset_id}/documents/delete_where": {
|
|
489
|
-
/**
|
|
1812
|
+
/**
|
|
1813
|
+
* Delete documents that match on a filters. At least one filter must be provided.
|
|
1814
|
+
*
|
|
1815
|
+
* ### Required permissions
|
|
1816
|
+
* > [
|
|
1817
|
+
* {
|
|
1818
|
+
* "actions": [
|
|
1819
|
+
* "datasets:write"
|
|
1820
|
+
* ],
|
|
1821
|
+
* "datasets": [
|
|
1822
|
+
* {
|
|
1823
|
+
* "params": "dataset_id"
|
|
1824
|
+
* }
|
|
1825
|
+
* ]
|
|
1826
|
+
* }
|
|
1827
|
+
* ]
|
|
1828
|
+
*/
|
|
490
1829
|
post: operations["DeleteWhere"];
|
|
491
1830
|
};
|
|
492
1831
|
"/datasets/{dataset_id}/simple_search": {
|
|
493
|
-
/**
|
|
1832
|
+
/**
|
|
1833
|
+
* SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
|
|
1834
|
+
*
|
|
1835
|
+
* ### Required permissions
|
|
1836
|
+
* > [
|
|
1837
|
+
* {
|
|
1838
|
+
* "actions": [
|
|
1839
|
+
* "datasets:read"
|
|
1840
|
+
* ],
|
|
1841
|
+
* "datasets": [
|
|
1842
|
+
* {
|
|
1843
|
+
* "params": "dataset_id"
|
|
1844
|
+
* }
|
|
1845
|
+
* ]
|
|
1846
|
+
* }
|
|
1847
|
+
* ]
|
|
1848
|
+
*/
|
|
494
1849
|
post: operations["SimpleSearchPost"];
|
|
495
1850
|
};
|
|
496
1851
|
"/datasets/{dataset_id}/search": {
|
|
497
|
-
/**
|
|
1852
|
+
/**
|
|
1853
|
+
* SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
|
|
1854
|
+
*
|
|
1855
|
+
* ### Required permissions
|
|
1856
|
+
* > [
|
|
1857
|
+
* {
|
|
1858
|
+
* "actions": [
|
|
1859
|
+
* "datasets:read"
|
|
1860
|
+
* ],
|
|
1861
|
+
* "datasets": [
|
|
1862
|
+
* {
|
|
1863
|
+
* "params": "dataset_id"
|
|
1864
|
+
* }
|
|
1865
|
+
* ]
|
|
1866
|
+
* }
|
|
1867
|
+
* ]
|
|
1868
|
+
*/
|
|
498
1869
|
post: operations["Search"];
|
|
499
1870
|
};
|
|
500
1871
|
"/datasets/{dataset_id}/recommend": {
|
|
501
|
-
/**
|
|
1872
|
+
/**
|
|
1873
|
+
* Recommend documents similar to specific documents. Specify which vector field must be used for recommendation using the documentsToRecommend property.
|
|
1874
|
+
*
|
|
1875
|
+
* ### Required permissions
|
|
1876
|
+
* > [
|
|
1877
|
+
* {
|
|
1878
|
+
* "actions": [
|
|
1879
|
+
* "datasets:read"
|
|
1880
|
+
* ],
|
|
1881
|
+
* "datasets": [
|
|
1882
|
+
* {
|
|
1883
|
+
* "params": "dataset_id"
|
|
1884
|
+
* }
|
|
1885
|
+
* ]
|
|
1886
|
+
* }
|
|
1887
|
+
* ]
|
|
1888
|
+
*/
|
|
502
1889
|
post: operations["Recommend"];
|
|
503
1890
|
};
|
|
504
1891
|
"/datasets/{dataset_id}/clone": {
|
|
1892
|
+
/**
|
|
1893
|
+
* ### Required permissions
|
|
1894
|
+
* > [
|
|
1895
|
+
* {
|
|
1896
|
+
* "actions": [
|
|
1897
|
+
* "datasets:read"
|
|
1898
|
+
* ],
|
|
1899
|
+
* "datasets": [
|
|
1900
|
+
* {
|
|
1901
|
+
* "params": "dataset_id"
|
|
1902
|
+
* }
|
|
1903
|
+
* ]
|
|
1904
|
+
* },
|
|
1905
|
+
* {
|
|
1906
|
+
* "actions": [
|
|
1907
|
+
* "datasets:write"
|
|
1908
|
+
* ],
|
|
1909
|
+
* "datasets": [
|
|
1910
|
+
* {
|
|
1911
|
+
* "body": "new_dataset_id"
|
|
1912
|
+
* }
|
|
1913
|
+
* ]
|
|
1914
|
+
* }
|
|
1915
|
+
* ]
|
|
1916
|
+
*/
|
|
505
1917
|
post: operations["CloneDataset"];
|
|
506
1918
|
};
|
|
507
1919
|
"/services/prediction/regression/knn": {
|
|
508
|
-
/**
|
|
1920
|
+
/**
|
|
1921
|
+
* Predict using KNN regression.
|
|
1922
|
+
*
|
|
1923
|
+
* ### Required permissions
|
|
1924
|
+
* > [
|
|
1925
|
+
* {
|
|
1926
|
+
* "actions": [
|
|
1927
|
+
* "datasets:read"
|
|
1928
|
+
* ],
|
|
1929
|
+
* "datasets": [
|
|
1930
|
+
* {
|
|
1931
|
+
* "body": "dataset_id"
|
|
1932
|
+
* }
|
|
1933
|
+
* ]
|
|
1934
|
+
* }
|
|
1935
|
+
* ]
|
|
1936
|
+
*/
|
|
509
1937
|
post: operations["PredictKNNRegression"];
|
|
510
1938
|
};
|
|
511
1939
|
"/services/prediction/knn_from_results": {
|
|
512
|
-
/**
|
|
1940
|
+
/**
|
|
1941
|
+
* Predict using KNN regression from search results.
|
|
1942
|
+
*
|
|
1943
|
+
* ### Required permissions
|
|
1944
|
+
* > []
|
|
1945
|
+
*/
|
|
513
1946
|
post: operations["PredictKNNFromResults"];
|
|
514
1947
|
};
|
|
515
1948
|
"/services/evaluation/bias": {
|
|
1949
|
+
/**
|
|
1950
|
+
* ### Required permissions
|
|
1951
|
+
* > []
|
|
1952
|
+
*/
|
|
516
1953
|
post: operations["BiasEvaluation"];
|
|
517
1954
|
};
|
|
518
1955
|
"/services/vectorize": {
|
|
1956
|
+
/**
|
|
1957
|
+
* ### Required permissions
|
|
1958
|
+
* > []
|
|
1959
|
+
*/
|
|
519
1960
|
post: operations["Vectorize"];
|
|
520
1961
|
};
|
|
521
1962
|
"/services/vectorize/{dataset_id}/vectorize_and_insert": {
|
|
1963
|
+
/**
|
|
1964
|
+
* ### Required permissions
|
|
1965
|
+
* > [
|
|
1966
|
+
* {
|
|
1967
|
+
* "actions": [
|
|
1968
|
+
* "datasets:write"
|
|
1969
|
+
* ],
|
|
1970
|
+
* "datasets": [
|
|
1971
|
+
* {
|
|
1972
|
+
* "params": "dataset_id"
|
|
1973
|
+
* }
|
|
1974
|
+
* ]
|
|
1975
|
+
* }
|
|
1976
|
+
* ]
|
|
1977
|
+
*/
|
|
522
1978
|
post: operations["VectorizeAndInsert"];
|
|
523
1979
|
};
|
|
524
1980
|
"/services/vectorize/{dataset_id}": {
|
|
1981
|
+
/**
|
|
1982
|
+
* ### Required permissions
|
|
1983
|
+
* > [
|
|
1984
|
+
* {
|
|
1985
|
+
* "actions": [
|
|
1986
|
+
* "datasets:write"
|
|
1987
|
+
* ],
|
|
1988
|
+
* "datasets": [
|
|
1989
|
+
* {
|
|
1990
|
+
* "params": "dataset_id"
|
|
1991
|
+
* }
|
|
1992
|
+
* ]
|
|
1993
|
+
* }
|
|
1994
|
+
* ]
|
|
1995
|
+
*/
|
|
525
1996
|
post: operations["VectorizeField"];
|
|
526
1997
|
};
|
|
527
1998
|
"/workflows/trigger": {
|
|
1999
|
+
/**
|
|
2000
|
+
* ### Required permissions
|
|
2001
|
+
* > [
|
|
2002
|
+
* {
|
|
2003
|
+
* "actions": [
|
|
2004
|
+
* "datasets:read",
|
|
2005
|
+
* "datasets:write"
|
|
2006
|
+
* ],
|
|
2007
|
+
* "datasets": [
|
|
2008
|
+
* {
|
|
2009
|
+
* "body": "dataset_id"
|
|
2010
|
+
* }
|
|
2011
|
+
* ]
|
|
2012
|
+
* }
|
|
2013
|
+
* ]
|
|
2014
|
+
*/
|
|
528
2015
|
post: operations["TriggerWorkflow"];
|
|
529
2016
|
};
|
|
530
2017
|
"/workflows/list": {
|
|
2018
|
+
/**
|
|
2019
|
+
* ### Required permissions
|
|
2020
|
+
* > [
|
|
2021
|
+
* {
|
|
2022
|
+
* "actions": [
|
|
2023
|
+
* "datasets:read"
|
|
2024
|
+
* ]
|
|
2025
|
+
* }
|
|
2026
|
+
* ]
|
|
2027
|
+
*/
|
|
531
2028
|
get: operations["ListWorkflows"];
|
|
532
2029
|
};
|
|
533
2030
|
"/workflows/{workflow_id}/get": {
|
|
2031
|
+
/**
|
|
2032
|
+
* ### Required permissions
|
|
2033
|
+
* > [
|
|
2034
|
+
* {
|
|
2035
|
+
* "actions": [
|
|
2036
|
+
* "datasets:read"
|
|
2037
|
+
* ]
|
|
2038
|
+
* }
|
|
2039
|
+
* ]
|
|
2040
|
+
*/
|
|
534
2041
|
post: operations["GetWorkflowStatus"];
|
|
535
2042
|
};
|
|
536
2043
|
"/workflows/{workflow_id}/delete": {
|
|
2044
|
+
/**
|
|
2045
|
+
* ### Required permissions
|
|
2046
|
+
* > [
|
|
2047
|
+
* {
|
|
2048
|
+
* "actions": [
|
|
2049
|
+
* "datasets:write"
|
|
2050
|
+
* ]
|
|
2051
|
+
* }
|
|
2052
|
+
* ]
|
|
2053
|
+
*/
|
|
537
2054
|
post: operations["DeleteWorkflowStatus"];
|
|
538
2055
|
};
|
|
539
2056
|
"/workflows/{workflow_id}/metadata": {
|
|
540
|
-
/**
|
|
2057
|
+
/**
|
|
2058
|
+
* Update metadata for a workflow run
|
|
2059
|
+
*
|
|
2060
|
+
* ### Required permissions
|
|
2061
|
+
* > [
|
|
2062
|
+
* {
|
|
2063
|
+
* "actions": [
|
|
2064
|
+
* "datasets:write"
|
|
2065
|
+
* ]
|
|
2066
|
+
* }
|
|
2067
|
+
* ]
|
|
2068
|
+
*/
|
|
541
2069
|
post: operations["UpsertWorkflowMetadata"];
|
|
542
2070
|
};
|
|
543
2071
|
"/workflows/{workflow_id}/status": {
|
|
544
|
-
/**
|
|
2072
|
+
/**
|
|
2073
|
+
* Update status for a workflow run
|
|
2074
|
+
*
|
|
2075
|
+
* ### Required permissions
|
|
2076
|
+
* > [
|
|
2077
|
+
* {
|
|
2078
|
+
* "actions": [
|
|
2079
|
+
* "datasets:write"
|
|
2080
|
+
* ]
|
|
2081
|
+
* }
|
|
2082
|
+
* ]
|
|
2083
|
+
*/
|
|
545
2084
|
post: operations["UpsertWorkflowStatus"];
|
|
546
2085
|
};
|
|
547
2086
|
"/datasets/{dataset_id}/field_children/{fieldchildren_id}/delete": {
|
|
2087
|
+
/**
|
|
2088
|
+
* ### Required permissions
|
|
2089
|
+
* > []
|
|
2090
|
+
*/
|
|
548
2091
|
post: operations["DeleteFieldChildren"];
|
|
549
2092
|
};
|
|
550
2093
|
"/datasets/{dataset_id}/field_children/list": {
|
|
2094
|
+
/**
|
|
2095
|
+
* ### Required permissions
|
|
2096
|
+
* > []
|
|
2097
|
+
*/
|
|
551
2098
|
post: operations["ListFieldChildrens"];
|
|
552
2099
|
};
|
|
553
2100
|
"/datasets/{dataset_id}/field_children/{fieldchildren_id}/update": {
|
|
2101
|
+
/**
|
|
2102
|
+
* ### Required permissions
|
|
2103
|
+
* > []
|
|
2104
|
+
*/
|
|
554
2105
|
post: operations["UpdateFieldChildren"];
|
|
555
2106
|
};
|
|
556
2107
|
"/workflows/favourites/{favouriteworkflow_id}/delete": {
|
|
2108
|
+
/**
|
|
2109
|
+
* ### Required permissions
|
|
2110
|
+
* > []
|
|
2111
|
+
*/
|
|
557
2112
|
post: operations["DeleteFavouriteWorkflow"];
|
|
558
2113
|
};
|
|
559
2114
|
"/workflows/favourites/list": {
|
|
2115
|
+
/**
|
|
2116
|
+
* ### Required permissions
|
|
2117
|
+
* > []
|
|
2118
|
+
*/
|
|
560
2119
|
post: operations["ListFavouriteWorkflows"];
|
|
561
2120
|
};
|
|
562
2121
|
"/workflows/favourites/{favouriteworkflow_id}/update": {
|
|
2122
|
+
/**
|
|
2123
|
+
* ### Required permissions
|
|
2124
|
+
* > []
|
|
2125
|
+
*/
|
|
563
2126
|
post: operations["UpdateFavouriteWorkflow"];
|
|
564
2127
|
};
|
|
2128
|
+
"/savedfilters/{savedfilter_id}/delete": {
|
|
2129
|
+
/**
|
|
2130
|
+
* ### Required permissions
|
|
2131
|
+
* > []
|
|
2132
|
+
*/
|
|
2133
|
+
post: operations["DeleteSavedFilter"];
|
|
2134
|
+
};
|
|
2135
|
+
"/savedfilters/list": {
|
|
2136
|
+
/**
|
|
2137
|
+
* ### Required permissions
|
|
2138
|
+
* > []
|
|
2139
|
+
*/
|
|
2140
|
+
post: operations["ListSavedFilters"];
|
|
2141
|
+
};
|
|
2142
|
+
"/savedfilters/{savedfilter_id}/update": {
|
|
2143
|
+
/**
|
|
2144
|
+
* ### Required permissions
|
|
2145
|
+
* > []
|
|
2146
|
+
*/
|
|
2147
|
+
post: operations["UpdateSavedFilter"];
|
|
2148
|
+
};
|
|
2149
|
+
"/savedfilters/{savedfilter_id}/get": {
|
|
2150
|
+
/**
|
|
2151
|
+
* ### Required permissions
|
|
2152
|
+
* > []
|
|
2153
|
+
*/
|
|
2154
|
+
get: operations["GetSavedFilter"];
|
|
2155
|
+
};
|
|
2156
|
+
"/savedfilters/create": {
|
|
2157
|
+
/**
|
|
2158
|
+
* ### Required permissions
|
|
2159
|
+
* > []
|
|
2160
|
+
*/
|
|
2161
|
+
post: operations["CreateSavedFilter"];
|
|
2162
|
+
};
|
|
565
2163
|
}
|
|
566
2164
|
export interface components {
|
|
567
2165
|
schemas: {
|
|
@@ -653,10 +2251,70 @@ export interface components {
|
|
|
653
2251
|
[key: string]: unknown;
|
|
654
2252
|
};
|
|
655
2253
|
private?: boolean;
|
|
656
|
-
updated_at?: string;
|
|
2254
|
+
updated_at?: string;
|
|
2255
|
+
}[];
|
|
2256
|
+
count: number;
|
|
2257
|
+
};
|
|
2258
|
+
DeleteDeployableGroupInput: unknown;
|
|
2259
|
+
DeleteDeployableGroupOutput: unknown;
|
|
2260
|
+
ListDeployableGroupsInput: {
|
|
2261
|
+
[key: string]: unknown;
|
|
2262
|
+
};
|
|
2263
|
+
ListDeployableGroupsOutput: {
|
|
2264
|
+
results: {
|
|
2265
|
+
_id?: string;
|
|
2266
|
+
name?: string;
|
|
2267
|
+
description?: string;
|
|
2268
|
+
deployables?: {
|
|
2269
|
+
id: string;
|
|
2270
|
+
name?: string;
|
|
2271
|
+
api_key?: string;
|
|
2272
|
+
private?: boolean;
|
|
2273
|
+
}[];
|
|
2274
|
+
}[];
|
|
2275
|
+
};
|
|
2276
|
+
CreateDeployableGroupInput: {
|
|
2277
|
+
_id?: string;
|
|
2278
|
+
name?: string;
|
|
2279
|
+
description?: string;
|
|
2280
|
+
deployables?: {
|
|
2281
|
+
id: string;
|
|
2282
|
+
name?: string;
|
|
2283
|
+
api_key?: string;
|
|
2284
|
+
private?: boolean;
|
|
2285
|
+
}[];
|
|
2286
|
+
};
|
|
2287
|
+
CreateDeployableGroupOutput: {
|
|
2288
|
+
id: string;
|
|
2289
|
+
};
|
|
2290
|
+
GetDeployableGroupInput: unknown;
|
|
2291
|
+
GetDeployableGroupOutput: {
|
|
2292
|
+
_id?: string;
|
|
2293
|
+
name?: string;
|
|
2294
|
+
description?: string;
|
|
2295
|
+
deployables?: {
|
|
2296
|
+
id: string;
|
|
2297
|
+
name?: string;
|
|
2298
|
+
api_key?: string;
|
|
2299
|
+
private?: boolean;
|
|
2300
|
+
}[];
|
|
2301
|
+
};
|
|
2302
|
+
UpdateDeployableGroupInput: {
|
|
2303
|
+
_id?: string;
|
|
2304
|
+
name?: string;
|
|
2305
|
+
description?: string;
|
|
2306
|
+
deployables?: {
|
|
2307
|
+
id: string;
|
|
2308
|
+
name?: string;
|
|
2309
|
+
api_key?: string;
|
|
2310
|
+
private?: boolean;
|
|
657
2311
|
}[];
|
|
658
|
-
count: number;
|
|
659
2312
|
};
|
|
2313
|
+
UpdateDeployableGroupOutput: unknown;
|
|
2314
|
+
CreateDeployableGroupKeyInput: unknown;
|
|
2315
|
+
CreateDeployableGroupKeyOutput: unknown;
|
|
2316
|
+
DeleteDeployableGroupKeyInput: unknown;
|
|
2317
|
+
DeleteDeployableGroupKeyOutput: unknown;
|
|
660
2318
|
CreateProjectInput: {
|
|
661
2319
|
/** @description The name of the project */
|
|
662
2320
|
name?: string;
|
|
@@ -1092,6 +2750,8 @@ export interface components {
|
|
|
1092
2750
|
ListUserKeysOutput: {
|
|
1093
2751
|
results: {
|
|
1094
2752
|
_id: string;
|
|
2753
|
+
label?: string;
|
|
2754
|
+
notes?: string;
|
|
1095
2755
|
}[];
|
|
1096
2756
|
};
|
|
1097
2757
|
DeleteUserKeyInput: {
|
|
@@ -4012,7 +5672,7 @@ export interface components {
|
|
|
4012
5672
|
/** @description The model url to use */
|
|
4013
5673
|
model_url?: string;
|
|
4014
5674
|
/** @description The model name to use. */
|
|
4015
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
5675
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
4016
5676
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
4017
5677
|
body?: string;
|
|
4018
5678
|
/** @description The document field to encode. */
|
|
@@ -4084,7 +5744,7 @@ export interface components {
|
|
|
4084
5744
|
/** @description The model url to use */
|
|
4085
5745
|
model_url?: string;
|
|
4086
5746
|
/** @description The model name to use. */
|
|
4087
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
5747
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
4088
5748
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
4089
5749
|
body?: string;
|
|
4090
5750
|
/** @description The document field to encode. */
|
|
@@ -4824,7 +6484,7 @@ export interface components {
|
|
|
4824
6484
|
/** @description The model url to use */
|
|
4825
6485
|
model_url?: string;
|
|
4826
6486
|
/** @description The model name to use. */
|
|
4827
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
6487
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
4828
6488
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
4829
6489
|
body?: string;
|
|
4830
6490
|
/** @description The document field to encode. */
|
|
@@ -4909,7 +6569,7 @@ export interface components {
|
|
|
4909
6569
|
/** @description The model url to use */
|
|
4910
6570
|
model_url?: string;
|
|
4911
6571
|
/** @description The model name to use. */
|
|
4912
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
6572
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
4913
6573
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
4914
6574
|
body?: string;
|
|
4915
6575
|
/** @description The document field to encode. */
|
|
@@ -7436,7 +9096,7 @@ export interface components {
|
|
|
7436
9096
|
/** @description The model url to use */
|
|
7437
9097
|
model_url?: string;
|
|
7438
9098
|
/** @description The model name to use. */
|
|
7439
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
9099
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
7440
9100
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
7441
9101
|
body?: string;
|
|
7442
9102
|
/** @description The document field to encode. */
|
|
@@ -7454,7 +9114,7 @@ export interface components {
|
|
|
7454
9114
|
/** @description The model url to use */
|
|
7455
9115
|
model_url?: string;
|
|
7456
9116
|
/** @description The model name to use. */
|
|
7457
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
9117
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
7458
9118
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
7459
9119
|
body?: string;
|
|
7460
9120
|
/** @description The document field to encode. */
|
|
@@ -7481,7 +9141,7 @@ export interface components {
|
|
|
7481
9141
|
/** @description The model url to use */
|
|
7482
9142
|
model_url?: string;
|
|
7483
9143
|
/** @description The model name to use. */
|
|
7484
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
9144
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
7485
9145
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
7486
9146
|
body?: string;
|
|
7487
9147
|
/** @description The document field to encode. */
|
|
@@ -7521,7 +9181,7 @@ export interface components {
|
|
|
7521
9181
|
/** @description The model url to use */
|
|
7522
9182
|
model_url?: string;
|
|
7523
9183
|
/** @description The model name to use. */
|
|
7524
|
-
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers";
|
|
9184
|
+
model_name?: "image_text" | "text_image" | "all-mpnet-base-v2" | "clip-vit-b-32-image" | "clip-vit-b-32-text" | "sentence-transformers" | "similarity-all-mpnet-base-v2";
|
|
7525
9185
|
/** @description Can be 'url' or 'text'. Use 'url' for image models and 'text' for text models. */
|
|
7526
9186
|
body?: string;
|
|
7527
9187
|
/** @description The document field to encode. */
|
|
@@ -7551,6 +9211,7 @@ export interface components {
|
|
|
7551
9211
|
notebook_path: string;
|
|
7552
9212
|
instance_type?: string;
|
|
7553
9213
|
dataset_id: string;
|
|
9214
|
+
workflow_id?: string;
|
|
7554
9215
|
};
|
|
7555
9216
|
TriggerWorkflowOutput: {
|
|
7556
9217
|
job_id: string;
|
|
@@ -7566,6 +9227,7 @@ export interface components {
|
|
|
7566
9227
|
[key: string]: unknown;
|
|
7567
9228
|
};
|
|
7568
9229
|
_id?: string;
|
|
9230
|
+
workflow_id?: string;
|
|
7569
9231
|
metadata?: {
|
|
7570
9232
|
[key: string]: unknown;
|
|
7571
9233
|
};
|
|
@@ -7586,6 +9248,7 @@ export interface components {
|
|
|
7586
9248
|
[key: string]: unknown;
|
|
7587
9249
|
};
|
|
7588
9250
|
_id?: string;
|
|
9251
|
+
workflow_id?: string;
|
|
7589
9252
|
metadata?: {
|
|
7590
9253
|
[key: string]: unknown;
|
|
7591
9254
|
};
|
|
@@ -7635,6 +9298,7 @@ export interface components {
|
|
|
7635
9298
|
metadata?: {
|
|
7636
9299
|
[key: string]: unknown;
|
|
7637
9300
|
};
|
|
9301
|
+
category?: string;
|
|
7638
9302
|
}[];
|
|
7639
9303
|
};
|
|
7640
9304
|
UpdateFieldChildrenInput: {
|
|
@@ -7644,6 +9308,7 @@ export interface components {
|
|
|
7644
9308
|
metadata?: {
|
|
7645
9309
|
[key: string]: unknown;
|
|
7646
9310
|
};
|
|
9311
|
+
category?: string;
|
|
7647
9312
|
};
|
|
7648
9313
|
UpdateFieldChildrenOutput: unknown;
|
|
7649
9314
|
DeleteFavouriteWorkflowInput: unknown;
|
|
@@ -7660,10 +9325,71 @@ export interface components {
|
|
|
7660
9325
|
_id?: string;
|
|
7661
9326
|
};
|
|
7662
9327
|
UpdateFavouriteWorkflowOutput: unknown;
|
|
9328
|
+
DeleteSavedFilterInput: unknown;
|
|
9329
|
+
DeleteSavedFilterOutput: unknown;
|
|
9330
|
+
ListSavedFiltersInput: {
|
|
9331
|
+
[key: string]: unknown;
|
|
9332
|
+
};
|
|
9333
|
+
ListSavedFiltersOutput: {
|
|
9334
|
+
results: {
|
|
9335
|
+
_id?: string;
|
|
9336
|
+
filters?: {
|
|
9337
|
+
[key: string]: unknown;
|
|
9338
|
+
};
|
|
9339
|
+
label?: string;
|
|
9340
|
+
name?: string;
|
|
9341
|
+
}[];
|
|
9342
|
+
};
|
|
9343
|
+
UpdateSavedFilterInput: {
|
|
9344
|
+
_id?: string;
|
|
9345
|
+
filters?: {
|
|
9346
|
+
[key: string]: unknown;
|
|
9347
|
+
};
|
|
9348
|
+
label?: string;
|
|
9349
|
+
name?: string;
|
|
9350
|
+
};
|
|
9351
|
+
UpdateSavedFilterOutput: unknown;
|
|
9352
|
+
GetSavedFilterInput: unknown;
|
|
9353
|
+
GetSavedFilterOutput: {
|
|
9354
|
+
_id?: string;
|
|
9355
|
+
filters?: {
|
|
9356
|
+
[key: string]: unknown;
|
|
9357
|
+
};
|
|
9358
|
+
label?: string;
|
|
9359
|
+
name?: string;
|
|
9360
|
+
};
|
|
9361
|
+
CreateSavedFilterInput: {
|
|
9362
|
+
_id?: string;
|
|
9363
|
+
filters?: {
|
|
9364
|
+
[key: string]: unknown;
|
|
9365
|
+
};
|
|
9366
|
+
label?: string;
|
|
9367
|
+
name?: string;
|
|
9368
|
+
};
|
|
9369
|
+
CreateSavedFilterOutput: {
|
|
9370
|
+
id: string;
|
|
9371
|
+
};
|
|
7663
9372
|
};
|
|
7664
9373
|
}
|
|
7665
9374
|
export interface operations {
|
|
7666
|
-
/**
|
|
9375
|
+
/**
|
|
9376
|
+
* Create a private deployable.
|
|
9377
|
+
*
|
|
9378
|
+
* ### Required permissions
|
|
9379
|
+
* > [
|
|
9380
|
+
* {
|
|
9381
|
+
* "actions": [
|
|
9382
|
+
* "deployables:write",
|
|
9383
|
+
* "datasets:read"
|
|
9384
|
+
* ],
|
|
9385
|
+
* "datasets": [
|
|
9386
|
+
* {
|
|
9387
|
+
* "body": "dataset_id"
|
|
9388
|
+
* }
|
|
9389
|
+
* ]
|
|
9390
|
+
* }
|
|
9391
|
+
* ]
|
|
9392
|
+
*/
|
|
7667
9393
|
CreateDeployable: {
|
|
7668
9394
|
parameters: {};
|
|
7669
9395
|
responses: {
|
|
@@ -7680,7 +9406,23 @@ export interface operations {
|
|
|
7680
9406
|
};
|
|
7681
9407
|
};
|
|
7682
9408
|
};
|
|
7683
|
-
/**
|
|
9409
|
+
/**
|
|
9410
|
+
* Get a deployable.
|
|
9411
|
+
*
|
|
9412
|
+
* ### Required permissions
|
|
9413
|
+
* > [
|
|
9414
|
+
* {
|
|
9415
|
+
* "actions": [
|
|
9416
|
+
* "deployables:read"
|
|
9417
|
+
* ],
|
|
9418
|
+
* "deployables": [
|
|
9419
|
+
* {
|
|
9420
|
+
* "params": "deployable_id"
|
|
9421
|
+
* }
|
|
9422
|
+
* ]
|
|
9423
|
+
* }
|
|
9424
|
+
* ]
|
|
9425
|
+
*/
|
|
7684
9426
|
GetDeployable: {
|
|
7685
9427
|
parameters: {
|
|
7686
9428
|
path: {
|
|
@@ -7697,7 +9439,33 @@ export interface operations {
|
|
|
7697
9439
|
};
|
|
7698
9440
|
};
|
|
7699
9441
|
};
|
|
7700
|
-
/**
|
|
9442
|
+
/**
|
|
9443
|
+
* Update a deployable
|
|
9444
|
+
*
|
|
9445
|
+
* ### Required permissions
|
|
9446
|
+
* > [
|
|
9447
|
+
* {
|
|
9448
|
+
* "actions": [
|
|
9449
|
+
* "deployables:write"
|
|
9450
|
+
* ],
|
|
9451
|
+
* "deployables": [
|
|
9452
|
+
* {
|
|
9453
|
+
* "params": "deployable_id"
|
|
9454
|
+
* }
|
|
9455
|
+
* ]
|
|
9456
|
+
* },
|
|
9457
|
+
* {
|
|
9458
|
+
* "actions": [
|
|
9459
|
+
* "datasets:read"
|
|
9460
|
+
* ],
|
|
9461
|
+
* "datasets": [
|
|
9462
|
+
* {
|
|
9463
|
+
* "body": "dataset_id"
|
|
9464
|
+
* }
|
|
9465
|
+
* ]
|
|
9466
|
+
* }
|
|
9467
|
+
* ]
|
|
9468
|
+
*/
|
|
7701
9469
|
UpdateDeployable: {
|
|
7702
9470
|
parameters: {
|
|
7703
9471
|
path: {
|
|
@@ -7719,6 +9487,21 @@ export interface operations {
|
|
|
7719
9487
|
};
|
|
7720
9488
|
};
|
|
7721
9489
|
};
|
|
9490
|
+
/**
|
|
9491
|
+
* ### Required permissions
|
|
9492
|
+
* > [
|
|
9493
|
+
* {
|
|
9494
|
+
* "actions": [
|
|
9495
|
+
* "deployables:write"
|
|
9496
|
+
* ],
|
|
9497
|
+
* "deployables": [
|
|
9498
|
+
* {
|
|
9499
|
+
* "body": "id"
|
|
9500
|
+
* }
|
|
9501
|
+
* ]
|
|
9502
|
+
* }
|
|
9503
|
+
* ]
|
|
9504
|
+
*/
|
|
7722
9505
|
DeleteDeployable: {
|
|
7723
9506
|
parameters: {};
|
|
7724
9507
|
responses: {
|
|
@@ -7735,7 +9518,24 @@ export interface operations {
|
|
|
7735
9518
|
};
|
|
7736
9519
|
};
|
|
7737
9520
|
};
|
|
7738
|
-
/**
|
|
9521
|
+
/**
|
|
9522
|
+
* Share a private deployable.
|
|
9523
|
+
*
|
|
9524
|
+
* ### Required permissions
|
|
9525
|
+
* > [
|
|
9526
|
+
* {
|
|
9527
|
+
* "actions": [
|
|
9528
|
+
* "sharing:write",
|
|
9529
|
+
* "deployables:read"
|
|
9530
|
+
* ],
|
|
9531
|
+
* "deployables": [
|
|
9532
|
+
* {
|
|
9533
|
+
* "params": "deployable_id"
|
|
9534
|
+
* }
|
|
9535
|
+
* ]
|
|
9536
|
+
* }
|
|
9537
|
+
* ]
|
|
9538
|
+
*/
|
|
7739
9539
|
CreateDeployableKey: {
|
|
7740
9540
|
parameters: {
|
|
7741
9541
|
path: {
|
|
@@ -7757,6 +9557,22 @@ export interface operations {
|
|
|
7757
9557
|
};
|
|
7758
9558
|
};
|
|
7759
9559
|
};
|
|
9560
|
+
/**
|
|
9561
|
+
* ### Required permissions
|
|
9562
|
+
* > [
|
|
9563
|
+
* {
|
|
9564
|
+
* "actions": [
|
|
9565
|
+
* "users:write",
|
|
9566
|
+
* "deployables:read"
|
|
9567
|
+
* ],
|
|
9568
|
+
* "deployables": [
|
|
9569
|
+
* {
|
|
9570
|
+
* "params": "deployable_id"
|
|
9571
|
+
* }
|
|
9572
|
+
* ]
|
|
9573
|
+
* }
|
|
9574
|
+
* ]
|
|
9575
|
+
*/
|
|
7760
9576
|
CreateDeployableInvite: {
|
|
7761
9577
|
parameters: {
|
|
7762
9578
|
path: {
|
|
@@ -7778,6 +9594,22 @@ export interface operations {
|
|
|
7778
9594
|
};
|
|
7779
9595
|
};
|
|
7780
9596
|
};
|
|
9597
|
+
/**
|
|
9598
|
+
* ### Required permissions
|
|
9599
|
+
* > [
|
|
9600
|
+
* {
|
|
9601
|
+
* "actions": [
|
|
9602
|
+
* "users:write",
|
|
9603
|
+
* "deployables:read"
|
|
9604
|
+
* ],
|
|
9605
|
+
* "deployables": [
|
|
9606
|
+
* {
|
|
9607
|
+
* "params": "deployable_id"
|
|
9608
|
+
* }
|
|
9609
|
+
* ]
|
|
9610
|
+
* }
|
|
9611
|
+
* ]
|
|
9612
|
+
*/
|
|
7781
9613
|
UpdateUsersDeployablePermissions: {
|
|
7782
9614
|
parameters: {
|
|
7783
9615
|
path: {
|
|
@@ -7801,7 +9633,24 @@ export interface operations {
|
|
|
7801
9633
|
};
|
|
7802
9634
|
};
|
|
7803
9635
|
};
|
|
7804
|
-
/**
|
|
9636
|
+
/**
|
|
9637
|
+
* Unshare a shared deployable, making it private.
|
|
9638
|
+
*
|
|
9639
|
+
* ### Required permissions
|
|
9640
|
+
* > [
|
|
9641
|
+
* {
|
|
9642
|
+
* "actions": [
|
|
9643
|
+
* "sharing:write",
|
|
9644
|
+
* "deployables:read"
|
|
9645
|
+
* ],
|
|
9646
|
+
* "deployables": [
|
|
9647
|
+
* {
|
|
9648
|
+
* "params": "deployable_id"
|
|
9649
|
+
* }
|
|
9650
|
+
* ]
|
|
9651
|
+
* }
|
|
9652
|
+
* ]
|
|
9653
|
+
*/
|
|
7805
9654
|
DeleteDeployableKey: {
|
|
7806
9655
|
parameters: {
|
|
7807
9656
|
path: {
|
|
@@ -7823,7 +9672,16 @@ export interface operations {
|
|
|
7823
9672
|
};
|
|
7824
9673
|
};
|
|
7825
9674
|
};
|
|
7826
|
-
/**
|
|
9675
|
+
/**
|
|
9676
|
+
* List all deployables.
|
|
9677
|
+
*
|
|
9678
|
+
* ### Required permissions
|
|
9679
|
+
* > [
|
|
9680
|
+
* {
|
|
9681
|
+
* "actions": []
|
|
9682
|
+
* }
|
|
9683
|
+
* ]
|
|
9684
|
+
*/
|
|
7827
9685
|
ListDeployables: {
|
|
7828
9686
|
parameters: {
|
|
7829
9687
|
query: {
|
|
@@ -7844,7 +9702,199 @@ export interface operations {
|
|
|
7844
9702
|
};
|
|
7845
9703
|
};
|
|
7846
9704
|
};
|
|
7847
|
-
/**
|
|
9705
|
+
/**
|
|
9706
|
+
* ### Required permissions
|
|
9707
|
+
* > []
|
|
9708
|
+
*/
|
|
9709
|
+
DeleteDeployableGroup: {
|
|
9710
|
+
parameters: {
|
|
9711
|
+
path: {
|
|
9712
|
+
/** ID of deployablegroup */
|
|
9713
|
+
deployablegroup_id: string;
|
|
9714
|
+
};
|
|
9715
|
+
};
|
|
9716
|
+
responses: {
|
|
9717
|
+
/** successful operation */
|
|
9718
|
+
200: {
|
|
9719
|
+
content: {
|
|
9720
|
+
"application/json": components["schemas"]["DeleteDeployableGroupOutput"];
|
|
9721
|
+
};
|
|
9722
|
+
};
|
|
9723
|
+
};
|
|
9724
|
+
requestBody: {
|
|
9725
|
+
content: {
|
|
9726
|
+
"application/json": components["schemas"]["DeleteDeployableGroupInput"];
|
|
9727
|
+
};
|
|
9728
|
+
};
|
|
9729
|
+
};
|
|
9730
|
+
/**
|
|
9731
|
+
* ### Required permissions
|
|
9732
|
+
* > []
|
|
9733
|
+
*/
|
|
9734
|
+
ListDeployableGroups: {
|
|
9735
|
+
parameters: {};
|
|
9736
|
+
responses: {
|
|
9737
|
+
/** successful operation */
|
|
9738
|
+
200: {
|
|
9739
|
+
content: {
|
|
9740
|
+
"application/json": components["schemas"]["ListDeployableGroupsOutput"];
|
|
9741
|
+
};
|
|
9742
|
+
};
|
|
9743
|
+
};
|
|
9744
|
+
requestBody: {
|
|
9745
|
+
content: {
|
|
9746
|
+
"application/json": components["schemas"]["ListDeployableGroupsInput"];
|
|
9747
|
+
};
|
|
9748
|
+
};
|
|
9749
|
+
};
|
|
9750
|
+
/**
|
|
9751
|
+
* ### Required permissions
|
|
9752
|
+
* > []
|
|
9753
|
+
*/
|
|
9754
|
+
CreateDeployableGroup: {
|
|
9755
|
+
parameters: {};
|
|
9756
|
+
responses: {
|
|
9757
|
+
/** successful operation */
|
|
9758
|
+
200: {
|
|
9759
|
+
content: {
|
|
9760
|
+
"application/json": components["schemas"]["CreateDeployableGroupOutput"];
|
|
9761
|
+
};
|
|
9762
|
+
};
|
|
9763
|
+
};
|
|
9764
|
+
requestBody: {
|
|
9765
|
+
content: {
|
|
9766
|
+
"application/json": components["schemas"]["CreateDeployableGroupInput"];
|
|
9767
|
+
};
|
|
9768
|
+
};
|
|
9769
|
+
};
|
|
9770
|
+
/**
|
|
9771
|
+
* ### Required permissions
|
|
9772
|
+
* > []
|
|
9773
|
+
*/
|
|
9774
|
+
GetDeployableGroup: {
|
|
9775
|
+
parameters: {
|
|
9776
|
+
path: {
|
|
9777
|
+
/** ID of deployablegroup */
|
|
9778
|
+
deployablegroup_id: string;
|
|
9779
|
+
};
|
|
9780
|
+
};
|
|
9781
|
+
responses: {
|
|
9782
|
+
/** successful operation */
|
|
9783
|
+
200: {
|
|
9784
|
+
content: {
|
|
9785
|
+
"application/json": components["schemas"]["GetDeployableGroupOutput"];
|
|
9786
|
+
};
|
|
9787
|
+
};
|
|
9788
|
+
};
|
|
9789
|
+
};
|
|
9790
|
+
/**
|
|
9791
|
+
* ### Required permissions
|
|
9792
|
+
* > []
|
|
9793
|
+
*/
|
|
9794
|
+
UpdateDeployableGroup: {
|
|
9795
|
+
parameters: {
|
|
9796
|
+
path: {
|
|
9797
|
+
/** ID of deployablegroup */
|
|
9798
|
+
deployablegroup_id: string;
|
|
9799
|
+
};
|
|
9800
|
+
};
|
|
9801
|
+
responses: {
|
|
9802
|
+
/** successful operation */
|
|
9803
|
+
200: {
|
|
9804
|
+
content: {
|
|
9805
|
+
"application/json": components["schemas"]["UpdateDeployableGroupOutput"];
|
|
9806
|
+
};
|
|
9807
|
+
};
|
|
9808
|
+
};
|
|
9809
|
+
requestBody: {
|
|
9810
|
+
content: {
|
|
9811
|
+
"application/json": components["schemas"]["UpdateDeployableGroupInput"];
|
|
9812
|
+
};
|
|
9813
|
+
};
|
|
9814
|
+
};
|
|
9815
|
+
/**
|
|
9816
|
+
* Share a private deployable group. Required read access to all deployables that are shared, and the datasets deployables are tied to.
|
|
9817
|
+
*
|
|
9818
|
+
* ### Required permissions
|
|
9819
|
+
* > [
|
|
9820
|
+
* {
|
|
9821
|
+
* "actions": [
|
|
9822
|
+
* "sharing:write"
|
|
9823
|
+
* ]
|
|
9824
|
+
* }
|
|
9825
|
+
* ]
|
|
9826
|
+
*/
|
|
9827
|
+
CreateDeployableGroupKey: {
|
|
9828
|
+
parameters: {
|
|
9829
|
+
path: {
|
|
9830
|
+
/** ID of deployablegroup */
|
|
9831
|
+
deployablegroup_id: string;
|
|
9832
|
+
};
|
|
9833
|
+
};
|
|
9834
|
+
responses: {
|
|
9835
|
+
/** successful operation */
|
|
9836
|
+
200: {
|
|
9837
|
+
content: {
|
|
9838
|
+
"application/json": components["schemas"]["CreateDeployableGroupKeyOutput"];
|
|
9839
|
+
};
|
|
9840
|
+
};
|
|
9841
|
+
};
|
|
9842
|
+
requestBody: {
|
|
9843
|
+
content: {
|
|
9844
|
+
"application/json": components["schemas"]["CreateDeployableGroupKeyInput"];
|
|
9845
|
+
};
|
|
9846
|
+
};
|
|
9847
|
+
};
|
|
9848
|
+
/**
|
|
9849
|
+
* Unshare a shared deployable group, making it private.
|
|
9850
|
+
*
|
|
9851
|
+
* ### Required permissions
|
|
9852
|
+
* > [
|
|
9853
|
+
* {
|
|
9854
|
+
* "actions": [
|
|
9855
|
+
* "sharing:write"
|
|
9856
|
+
* ]
|
|
9857
|
+
* }
|
|
9858
|
+
* ]
|
|
9859
|
+
*/
|
|
9860
|
+
DeleteDeployableGroupKey: {
|
|
9861
|
+
parameters: {
|
|
9862
|
+
path: {
|
|
9863
|
+
/** ID of deployablegroup */
|
|
9864
|
+
deployablegroup_id: string;
|
|
9865
|
+
};
|
|
9866
|
+
};
|
|
9867
|
+
responses: {
|
|
9868
|
+
/** successful operation */
|
|
9869
|
+
200: {
|
|
9870
|
+
content: {
|
|
9871
|
+
"application/json": components["schemas"]["DeleteDeployableGroupKeyOutput"];
|
|
9872
|
+
};
|
|
9873
|
+
};
|
|
9874
|
+
};
|
|
9875
|
+
requestBody: {
|
|
9876
|
+
content: {
|
|
9877
|
+
"application/json": components["schemas"]["DeleteDeployableGroupKeyInput"];
|
|
9878
|
+
};
|
|
9879
|
+
};
|
|
9880
|
+
};
|
|
9881
|
+
/**
|
|
9882
|
+
* Create a new Project that your user will have access to
|
|
9883
|
+
*
|
|
9884
|
+
* ### Required permissions
|
|
9885
|
+
* > [
|
|
9886
|
+
* {
|
|
9887
|
+
* "actions": [
|
|
9888
|
+
* "organizations:write"
|
|
9889
|
+
* ],
|
|
9890
|
+
* "organizations": [
|
|
9891
|
+
* {
|
|
9892
|
+
* "body": "organization_id"
|
|
9893
|
+
* }
|
|
9894
|
+
* ]
|
|
9895
|
+
* }
|
|
9896
|
+
* ]
|
|
9897
|
+
*/
|
|
7848
9898
|
CreateProject: {
|
|
7849
9899
|
parameters: {};
|
|
7850
9900
|
responses: {
|
|
@@ -7861,7 +9911,18 @@ export interface operations {
|
|
|
7861
9911
|
};
|
|
7862
9912
|
};
|
|
7863
9913
|
};
|
|
7864
|
-
/**
|
|
9914
|
+
/**
|
|
9915
|
+
* Update metadata of a Project
|
|
9916
|
+
*
|
|
9917
|
+
* ### Required permissions
|
|
9918
|
+
* > [
|
|
9919
|
+
* {
|
|
9920
|
+
* "actions": [
|
|
9921
|
+
* "admin"
|
|
9922
|
+
* ]
|
|
9923
|
+
* }
|
|
9924
|
+
* ]
|
|
9925
|
+
*/
|
|
7865
9926
|
UpdateProject: {
|
|
7866
9927
|
parameters: {};
|
|
7867
9928
|
responses: {
|
|
@@ -7878,7 +9939,33 @@ export interface operations {
|
|
|
7878
9939
|
};
|
|
7879
9940
|
};
|
|
7880
9941
|
};
|
|
7881
|
-
/**
|
|
9942
|
+
/**
|
|
9943
|
+
* Tie a project to an organization. This requires admin privileges over project and organization.
|
|
9944
|
+
*
|
|
9945
|
+
* ### Required permissions
|
|
9946
|
+
* > [
|
|
9947
|
+
* {
|
|
9948
|
+
* "actions": [
|
|
9949
|
+
* "admin"
|
|
9950
|
+
* ],
|
|
9951
|
+
* "projects": [
|
|
9952
|
+
* {
|
|
9953
|
+
* "user_info": "username"
|
|
9954
|
+
* }
|
|
9955
|
+
* ]
|
|
9956
|
+
* },
|
|
9957
|
+
* {
|
|
9958
|
+
* "actions": [
|
|
9959
|
+
* "organizations:write"
|
|
9960
|
+
* ],
|
|
9961
|
+
* "organizations": [
|
|
9962
|
+
* {
|
|
9963
|
+
* "body": "organization_id"
|
|
9964
|
+
* }
|
|
9965
|
+
* ]
|
|
9966
|
+
* }
|
|
9967
|
+
* ]
|
|
9968
|
+
*/
|
|
7882
9969
|
TransferProjectToOrganization: {
|
|
7883
9970
|
parameters: {};
|
|
7884
9971
|
responses: {
|
|
@@ -7895,7 +9982,12 @@ export interface operations {
|
|
|
7895
9982
|
};
|
|
7896
9983
|
};
|
|
7897
9984
|
};
|
|
7898
|
-
/**
|
|
9985
|
+
/**
|
|
9986
|
+
* List all projects and their metadata
|
|
9987
|
+
*
|
|
9988
|
+
* ### Required permissions
|
|
9989
|
+
* > []
|
|
9990
|
+
*/
|
|
7899
9991
|
ListProjects: {
|
|
7900
9992
|
parameters: {};
|
|
7901
9993
|
responses: {
|
|
@@ -7907,6 +9999,16 @@ export interface operations {
|
|
|
7907
9999
|
};
|
|
7908
10000
|
};
|
|
7909
10001
|
};
|
|
10002
|
+
/**
|
|
10003
|
+
* ### Required permissions
|
|
10004
|
+
* > [
|
|
10005
|
+
* {
|
|
10006
|
+
* "actions": [
|
|
10007
|
+
* "users:write"
|
|
10008
|
+
* ]
|
|
10009
|
+
* }
|
|
10010
|
+
* ]
|
|
10011
|
+
*/
|
|
7910
10012
|
CreateUser: {
|
|
7911
10013
|
parameters: {};
|
|
7912
10014
|
responses: {
|
|
@@ -7923,6 +10025,14 @@ export interface operations {
|
|
|
7923
10025
|
};
|
|
7924
10026
|
};
|
|
7925
10027
|
};
|
|
10028
|
+
/**
|
|
10029
|
+
* ### Required permissions
|
|
10030
|
+
* > [
|
|
10031
|
+
* {
|
|
10032
|
+
* "actions": []
|
|
10033
|
+
* }
|
|
10034
|
+
* ]
|
|
10035
|
+
*/
|
|
7926
10036
|
ListUsers: {
|
|
7927
10037
|
parameters: {};
|
|
7928
10038
|
responses: {
|
|
@@ -7939,6 +10049,10 @@ export interface operations {
|
|
|
7939
10049
|
};
|
|
7940
10050
|
};
|
|
7941
10051
|
};
|
|
10052
|
+
/**
|
|
10053
|
+
* ### Required permissions
|
|
10054
|
+
* > []
|
|
10055
|
+
*/
|
|
7942
10056
|
IsUserAuthorized: {
|
|
7943
10057
|
parameters: {};
|
|
7944
10058
|
responses: {
|
|
@@ -7955,7 +10069,12 @@ export interface operations {
|
|
|
7955
10069
|
};
|
|
7956
10070
|
};
|
|
7957
10071
|
};
|
|
7958
|
-
/**
|
|
10072
|
+
/**
|
|
10073
|
+
* Get user_id, key_id and permissions from an auth header.
|
|
10074
|
+
*
|
|
10075
|
+
* ### Required permissions
|
|
10076
|
+
* > []
|
|
10077
|
+
*/
|
|
7959
10078
|
GetAuthHeaderInfo: {
|
|
7960
10079
|
parameters: {};
|
|
7961
10080
|
responses: {
|
|
@@ -7967,7 +10086,18 @@ export interface operations {
|
|
|
7967
10086
|
};
|
|
7968
10087
|
};
|
|
7969
10088
|
};
|
|
7970
|
-
/**
|
|
10089
|
+
/**
|
|
10090
|
+
* Invite a user to a project using either their email or their user_id
|
|
10091
|
+
*
|
|
10092
|
+
* ### Required permissions
|
|
10093
|
+
* > [
|
|
10094
|
+
* {
|
|
10095
|
+
* "actions": [
|
|
10096
|
+
* "users:write"
|
|
10097
|
+
* ]
|
|
10098
|
+
* }
|
|
10099
|
+
* ]
|
|
10100
|
+
*/
|
|
7971
10101
|
CreateProjectInvite: {
|
|
7972
10102
|
parameters: {};
|
|
7973
10103
|
responses: {
|
|
@@ -7984,6 +10114,10 @@ export interface operations {
|
|
|
7984
10114
|
};
|
|
7985
10115
|
};
|
|
7986
10116
|
};
|
|
10117
|
+
/**
|
|
10118
|
+
* ### Required permissions
|
|
10119
|
+
* > []
|
|
10120
|
+
*/
|
|
7987
10121
|
ListProjectInvites: {
|
|
7988
10122
|
parameters: {};
|
|
7989
10123
|
responses: {
|
|
@@ -8000,6 +10134,10 @@ export interface operations {
|
|
|
8000
10134
|
};
|
|
8001
10135
|
};
|
|
8002
10136
|
};
|
|
10137
|
+
/**
|
|
10138
|
+
* ### Required permissions
|
|
10139
|
+
* > []
|
|
10140
|
+
*/
|
|
8003
10141
|
AcceptProjectInvite: {
|
|
8004
10142
|
parameters: {};
|
|
8005
10143
|
responses: {
|
|
@@ -8016,6 +10154,16 @@ export interface operations {
|
|
|
8016
10154
|
};
|
|
8017
10155
|
};
|
|
8018
10156
|
};
|
|
10157
|
+
/**
|
|
10158
|
+
* ### Required permissions
|
|
10159
|
+
* > [
|
|
10160
|
+
* {
|
|
10161
|
+
* "actions": [
|
|
10162
|
+
* "users:write"
|
|
10163
|
+
* ]
|
|
10164
|
+
* }
|
|
10165
|
+
* ]
|
|
10166
|
+
*/
|
|
8019
10167
|
DeleteProjectInvite: {
|
|
8020
10168
|
parameters: {};
|
|
8021
10169
|
responses: {
|
|
@@ -8032,6 +10180,16 @@ export interface operations {
|
|
|
8032
10180
|
};
|
|
8033
10181
|
};
|
|
8034
10182
|
};
|
|
10183
|
+
/**
|
|
10184
|
+
* ### Required permissions
|
|
10185
|
+
* > [
|
|
10186
|
+
* {
|
|
10187
|
+
* "actions": [
|
|
10188
|
+
* "users:write"
|
|
10189
|
+
* ]
|
|
10190
|
+
* }
|
|
10191
|
+
* ]
|
|
10192
|
+
*/
|
|
8035
10193
|
ResendProjectInvite: {
|
|
8036
10194
|
parameters: {};
|
|
8037
10195
|
responses: {
|
|
@@ -8048,6 +10206,21 @@ export interface operations {
|
|
|
8048
10206
|
};
|
|
8049
10207
|
};
|
|
8050
10208
|
};
|
|
10209
|
+
/**
|
|
10210
|
+
* ### Required permissions
|
|
10211
|
+
* > [
|
|
10212
|
+
* {
|
|
10213
|
+
* "users": [
|
|
10214
|
+
* {
|
|
10215
|
+
* "params": "user_id"
|
|
10216
|
+
* }
|
|
10217
|
+
* ],
|
|
10218
|
+
* "actions": [
|
|
10219
|
+
* "users:read"
|
|
10220
|
+
* ]
|
|
10221
|
+
* }
|
|
10222
|
+
* ]
|
|
10223
|
+
*/
|
|
8051
10224
|
GetUser: {
|
|
8052
10225
|
parameters: {
|
|
8053
10226
|
path: {
|
|
@@ -8064,6 +10237,21 @@ export interface operations {
|
|
|
8064
10237
|
};
|
|
8065
10238
|
};
|
|
8066
10239
|
};
|
|
10240
|
+
/**
|
|
10241
|
+
* ### Required permissions
|
|
10242
|
+
* > [
|
|
10243
|
+
* {
|
|
10244
|
+
* "users": [
|
|
10245
|
+
* {
|
|
10246
|
+
* "params": "user_id"
|
|
10247
|
+
* }
|
|
10248
|
+
* ],
|
|
10249
|
+
* "actions": [
|
|
10250
|
+
* "users:write"
|
|
10251
|
+
* ]
|
|
10252
|
+
* }
|
|
10253
|
+
* ]
|
|
10254
|
+
*/
|
|
8067
10255
|
UpdateUser: {
|
|
8068
10256
|
parameters: {
|
|
8069
10257
|
path: {
|
|
@@ -8085,7 +10273,23 @@ export interface operations {
|
|
|
8085
10273
|
};
|
|
8086
10274
|
};
|
|
8087
10275
|
};
|
|
8088
|
-
/**
|
|
10276
|
+
/**
|
|
10277
|
+
* Deletes a User from ONLY your project. If they have permissions for other projects, they will still have acces to them.
|
|
10278
|
+
*
|
|
10279
|
+
* ### Required permissions
|
|
10280
|
+
* > [
|
|
10281
|
+
* {
|
|
10282
|
+
* "users": [
|
|
10283
|
+
* {
|
|
10284
|
+
* "params": "user_id"
|
|
10285
|
+
* }
|
|
10286
|
+
* ],
|
|
10287
|
+
* "actions": [
|
|
10288
|
+
* "users:write"
|
|
10289
|
+
* ]
|
|
10290
|
+
* }
|
|
10291
|
+
* ]
|
|
10292
|
+
*/
|
|
8089
10293
|
DeleteUser: {
|
|
8090
10294
|
parameters: {
|
|
8091
10295
|
path: {
|
|
@@ -8107,6 +10311,21 @@ export interface operations {
|
|
|
8107
10311
|
};
|
|
8108
10312
|
};
|
|
8109
10313
|
};
|
|
10314
|
+
/**
|
|
10315
|
+
* ### Required permissions
|
|
10316
|
+
* > [
|
|
10317
|
+
* {
|
|
10318
|
+
* "users": [
|
|
10319
|
+
* {
|
|
10320
|
+
* "params": "user_id"
|
|
10321
|
+
* }
|
|
10322
|
+
* ],
|
|
10323
|
+
* "actions": [
|
|
10324
|
+
* "users:write"
|
|
10325
|
+
* ]
|
|
10326
|
+
* }
|
|
10327
|
+
* ]
|
|
10328
|
+
*/
|
|
8110
10329
|
CreateUserKey: {
|
|
8111
10330
|
parameters: {
|
|
8112
10331
|
path: {
|
|
@@ -8128,6 +10347,21 @@ export interface operations {
|
|
|
8128
10347
|
};
|
|
8129
10348
|
};
|
|
8130
10349
|
};
|
|
10350
|
+
/**
|
|
10351
|
+
* ### Required permissions
|
|
10352
|
+
* > [
|
|
10353
|
+
* {
|
|
10354
|
+
* "users": [
|
|
10355
|
+
* {
|
|
10356
|
+
* "params": "user_id"
|
|
10357
|
+
* }
|
|
10358
|
+
* ],
|
|
10359
|
+
* "actions": [
|
|
10360
|
+
* "users:read"
|
|
10361
|
+
* ]
|
|
10362
|
+
* }
|
|
10363
|
+
* ]
|
|
10364
|
+
*/
|
|
8131
10365
|
ListUserKeys: {
|
|
8132
10366
|
parameters: {
|
|
8133
10367
|
path: {
|
|
@@ -8149,6 +10383,21 @@ export interface operations {
|
|
|
8149
10383
|
};
|
|
8150
10384
|
};
|
|
8151
10385
|
};
|
|
10386
|
+
/**
|
|
10387
|
+
* ### Required permissions
|
|
10388
|
+
* > [
|
|
10389
|
+
* {
|
|
10390
|
+
* "users": [
|
|
10391
|
+
* {
|
|
10392
|
+
* "params": "user_id"
|
|
10393
|
+
* }
|
|
10394
|
+
* ],
|
|
10395
|
+
* "actions": [
|
|
10396
|
+
* "users:write"
|
|
10397
|
+
* ]
|
|
10398
|
+
* }
|
|
10399
|
+
* ]
|
|
10400
|
+
*/
|
|
8152
10401
|
DeleteUserKey: {
|
|
8153
10402
|
parameters: {
|
|
8154
10403
|
path: {
|
|
@@ -8170,7 +10419,23 @@ export interface operations {
|
|
|
8170
10419
|
};
|
|
8171
10420
|
};
|
|
8172
10421
|
};
|
|
8173
|
-
/**
|
|
10422
|
+
/**
|
|
10423
|
+
* Insert your own cluster centroids for it to be used in approximate search settings and cluster aggregations.
|
|
10424
|
+
*
|
|
10425
|
+
* ### Required permissions
|
|
10426
|
+
* > [
|
|
10427
|
+
* {
|
|
10428
|
+
* "actions": [
|
|
10429
|
+
* "datasets:write"
|
|
10430
|
+
* ],
|
|
10431
|
+
* "datasets": [
|
|
10432
|
+
* {
|
|
10433
|
+
* "params": "dataset_id"
|
|
10434
|
+
* }
|
|
10435
|
+
* ]
|
|
10436
|
+
* }
|
|
10437
|
+
* ]
|
|
10438
|
+
*/
|
|
8174
10439
|
InsertClusterCentroids: {
|
|
8175
10440
|
parameters: {
|
|
8176
10441
|
path: {
|
|
@@ -8192,7 +10457,23 @@ export interface operations {
|
|
|
8192
10457
|
};
|
|
8193
10458
|
};
|
|
8194
10459
|
};
|
|
8195
|
-
/**
|
|
10460
|
+
/**
|
|
10461
|
+
* Update your own cluster centroids for it to be used in approximate search settings and cluster aggregations. Will merge rather than replace centroids.
|
|
10462
|
+
*
|
|
10463
|
+
* ### Required permissions
|
|
10464
|
+
* > [
|
|
10465
|
+
* {
|
|
10466
|
+
* "actions": [
|
|
10467
|
+
* "datasets:write"
|
|
10468
|
+
* ],
|
|
10469
|
+
* "datasets": [
|
|
10470
|
+
* {
|
|
10471
|
+
* "params": "dataset_id"
|
|
10472
|
+
* }
|
|
10473
|
+
* ]
|
|
10474
|
+
* }
|
|
10475
|
+
* ]
|
|
10476
|
+
*/
|
|
8196
10477
|
UpdateClusterCentroids: {
|
|
8197
10478
|
parameters: {
|
|
8198
10479
|
path: {
|
|
@@ -8214,7 +10495,26 @@ export interface operations {
|
|
|
8214
10495
|
};
|
|
8215
10496
|
};
|
|
8216
10497
|
};
|
|
8217
|
-
/**
|
|
10498
|
+
/**
|
|
10499
|
+
* For each centroid in a list of centroids, find the closest centroids in another set of centroids.
|
|
10500
|
+
*
|
|
10501
|
+
* ### Required permissions
|
|
10502
|
+
* > [
|
|
10503
|
+
* {
|
|
10504
|
+
* "actions": [
|
|
10505
|
+
* "datasets:read"
|
|
10506
|
+
* ],
|
|
10507
|
+
* "datasets": [
|
|
10508
|
+
* {
|
|
10509
|
+
* "params": "dataset_id"
|
|
10510
|
+
* },
|
|
10511
|
+
* {
|
|
10512
|
+
* "body": "comparison_centroids.dataset_id"
|
|
10513
|
+
* }
|
|
10514
|
+
* ]
|
|
10515
|
+
* }
|
|
10516
|
+
* ]
|
|
10517
|
+
*/
|
|
8218
10518
|
CompareClusterCentroids: {
|
|
8219
10519
|
parameters: {
|
|
8220
10520
|
path: {
|
|
@@ -8291,6 +10591,22 @@ export interface operations {
|
|
|
8291
10591
|
* {"title": {"title": "books", "frequency": 200, "documents": [{...}, {...}]}, {"title": "books", "frequency": 100, "documents": [{...}, {...}]}}
|
|
8292
10592
|
*
|
|
8293
10593
|
* For array-aggregations, you can add "agg": "array" into the aggregation query.
|
|
10594
|
+
*
|
|
10595
|
+
*
|
|
10596
|
+
*
|
|
10597
|
+
* ### Required permissions
|
|
10598
|
+
* > [
|
|
10599
|
+
* {
|
|
10600
|
+
* "actions": [
|
|
10601
|
+
* "datasets:read"
|
|
10602
|
+
* ],
|
|
10603
|
+
* "datasets": [
|
|
10604
|
+
* {
|
|
10605
|
+
* "params": "dataset_id"
|
|
10606
|
+
* }
|
|
10607
|
+
* ]
|
|
10608
|
+
* }
|
|
10609
|
+
* ]
|
|
8294
10610
|
*/
|
|
8295
10611
|
Aggregate: {
|
|
8296
10612
|
parameters: {
|
|
@@ -8313,7 +10629,23 @@ export interface operations {
|
|
|
8313
10629
|
};
|
|
8314
10630
|
};
|
|
8315
10631
|
};
|
|
8316
|
-
/**
|
|
10632
|
+
/**
|
|
10633
|
+
* Takes an aggregation query and gets the aggregate of each cluster in a collection. This helps you interpret each cluster and what is in them.
|
|
10634
|
+
*
|
|
10635
|
+
* ### Required permissions
|
|
10636
|
+
* > [
|
|
10637
|
+
* {
|
|
10638
|
+
* "actions": [
|
|
10639
|
+
* "datasets:read"
|
|
10640
|
+
* ],
|
|
10641
|
+
* "datasets": [
|
|
10642
|
+
* {
|
|
10643
|
+
* "params": "dataset_id"
|
|
10644
|
+
* }
|
|
10645
|
+
* ]
|
|
10646
|
+
* }
|
|
10647
|
+
* ]
|
|
10648
|
+
*/
|
|
8317
10649
|
AggregateClusters: {
|
|
8318
10650
|
parameters: {
|
|
8319
10651
|
path: {
|
|
@@ -8335,7 +10667,23 @@ export interface operations {
|
|
|
8335
10667
|
};
|
|
8336
10668
|
};
|
|
8337
10669
|
};
|
|
8338
|
-
/**
|
|
10670
|
+
/**
|
|
10671
|
+
* Takes a high level aggregation of every field and every cluster in a collection. This helps you interpret each cluster and what is in them.
|
|
10672
|
+
*
|
|
10673
|
+
* ### Required permissions
|
|
10674
|
+
* > [
|
|
10675
|
+
* {
|
|
10676
|
+
* "actions": [
|
|
10677
|
+
* "datasets:read"
|
|
10678
|
+
* ],
|
|
10679
|
+
* "datasets": [
|
|
10680
|
+
* {
|
|
10681
|
+
* "params": "dataset_id"
|
|
10682
|
+
* }
|
|
10683
|
+
* ]
|
|
10684
|
+
* }
|
|
10685
|
+
* ]
|
|
10686
|
+
*/
|
|
8339
10687
|
ListClusterFacets: {
|
|
8340
10688
|
parameters: {
|
|
8341
10689
|
path: {
|
|
@@ -8357,7 +10705,23 @@ export interface operations {
|
|
|
8357
10705
|
};
|
|
8358
10706
|
};
|
|
8359
10707
|
};
|
|
8360
|
-
/**
|
|
10708
|
+
/**
|
|
10709
|
+
* List documents with vector fields closest to centroids.
|
|
10710
|
+
*
|
|
10711
|
+
* ### Required permissions
|
|
10712
|
+
* > [
|
|
10713
|
+
* {
|
|
10714
|
+
* "actions": [
|
|
10715
|
+
* "datasets:read"
|
|
10716
|
+
* ],
|
|
10717
|
+
* "datasets": [
|
|
10718
|
+
* {
|
|
10719
|
+
* "params": "dataset_id"
|
|
10720
|
+
* }
|
|
10721
|
+
* ]
|
|
10722
|
+
* }
|
|
10723
|
+
* ]
|
|
10724
|
+
*/
|
|
8361
10725
|
ListClosestToCentroids: {
|
|
8362
10726
|
parameters: {
|
|
8363
10727
|
path: {
|
|
@@ -8379,7 +10743,23 @@ export interface operations {
|
|
|
8379
10743
|
};
|
|
8380
10744
|
};
|
|
8381
10745
|
};
|
|
8382
|
-
/**
|
|
10746
|
+
/**
|
|
10747
|
+
* List documents with vector fields furthest from centroids.
|
|
10748
|
+
*
|
|
10749
|
+
* ### Required permissions
|
|
10750
|
+
* > [
|
|
10751
|
+
* {
|
|
10752
|
+
* "actions": [
|
|
10753
|
+
* "datasets:read"
|
|
10754
|
+
* ],
|
|
10755
|
+
* "datasets": [
|
|
10756
|
+
* {
|
|
10757
|
+
* "params": "dataset_id"
|
|
10758
|
+
* }
|
|
10759
|
+
* ]
|
|
10760
|
+
* }
|
|
10761
|
+
* ]
|
|
10762
|
+
*/
|
|
8383
10763
|
ListFurthestFromCentroids: {
|
|
8384
10764
|
parameters: {
|
|
8385
10765
|
path: {
|
|
@@ -8401,7 +10781,23 @@ export interface operations {
|
|
|
8401
10781
|
};
|
|
8402
10782
|
};
|
|
8403
10783
|
};
|
|
8404
|
-
/**
|
|
10784
|
+
/**
|
|
10785
|
+
* List centroids, optionally filtering by their ids.
|
|
10786
|
+
*
|
|
10787
|
+
* ### Required permissions
|
|
10788
|
+
* > [
|
|
10789
|
+
* {
|
|
10790
|
+
* "actions": [
|
|
10791
|
+
* "datasets:read"
|
|
10792
|
+
* ],
|
|
10793
|
+
* "datasets": [
|
|
10794
|
+
* {
|
|
10795
|
+
* "params": "dataset_id"
|
|
10796
|
+
* }
|
|
10797
|
+
* ]
|
|
10798
|
+
* }
|
|
10799
|
+
* ]
|
|
10800
|
+
*/
|
|
8405
10801
|
ListCentroids: {
|
|
8406
10802
|
parameters: {
|
|
8407
10803
|
path: {
|
|
@@ -8423,7 +10819,23 @@ export interface operations {
|
|
|
8423
10819
|
};
|
|
8424
10820
|
};
|
|
8425
10821
|
};
|
|
8426
|
-
/**
|
|
10822
|
+
/**
|
|
10823
|
+
* List centroids configs for a dataset.
|
|
10824
|
+
*
|
|
10825
|
+
* ### Required permissions
|
|
10826
|
+
* > [
|
|
10827
|
+
* {
|
|
10828
|
+
* "actions": [
|
|
10829
|
+
* "datasets:read"
|
|
10830
|
+
* ],
|
|
10831
|
+
* "datasets": [
|
|
10832
|
+
* {
|
|
10833
|
+
* "params": "dataset_id"
|
|
10834
|
+
* }
|
|
10835
|
+
* ]
|
|
10836
|
+
* }
|
|
10837
|
+
* ]
|
|
10838
|
+
*/
|
|
8427
10839
|
ListCentroidConfigs: {
|
|
8428
10840
|
parameters: {
|
|
8429
10841
|
path: {
|
|
@@ -8440,7 +10852,23 @@ export interface operations {
|
|
|
8440
10852
|
};
|
|
8441
10853
|
};
|
|
8442
10854
|
};
|
|
8443
|
-
/**
|
|
10855
|
+
/**
|
|
10856
|
+
* Delete a centroid by ID
|
|
10857
|
+
*
|
|
10858
|
+
* ### Required permissions
|
|
10859
|
+
* > [
|
|
10860
|
+
* {
|
|
10861
|
+
* "actions": [
|
|
10862
|
+
* "datasets:write"
|
|
10863
|
+
* ],
|
|
10864
|
+
* "datasets": [
|
|
10865
|
+
* {
|
|
10866
|
+
* "params": "dataset_id"
|
|
10867
|
+
* }
|
|
10868
|
+
* ]
|
|
10869
|
+
* }
|
|
10870
|
+
* ]
|
|
10871
|
+
*/
|
|
8444
10872
|
DeleteCentroid: {
|
|
8445
10873
|
parameters: {
|
|
8446
10874
|
path: {
|
|
@@ -8464,6 +10892,21 @@ export interface operations {
|
|
|
8464
10892
|
};
|
|
8465
10893
|
};
|
|
8466
10894
|
};
|
|
10895
|
+
/**
|
|
10896
|
+
* ### Required permissions
|
|
10897
|
+
* > [
|
|
10898
|
+
* {
|
|
10899
|
+
* "actions": [
|
|
10900
|
+
* "datasets:read"
|
|
10901
|
+
* ],
|
|
10902
|
+
* "datasets": [
|
|
10903
|
+
* {
|
|
10904
|
+
* "body": "dataset_id"
|
|
10905
|
+
* }
|
|
10906
|
+
* ]
|
|
10907
|
+
* }
|
|
10908
|
+
* ]
|
|
10909
|
+
*/
|
|
8467
10910
|
RealtimeClustering: {
|
|
8468
10911
|
parameters: {
|
|
8469
10912
|
path: {
|
|
@@ -8485,6 +10928,21 @@ export interface operations {
|
|
|
8485
10928
|
};
|
|
8486
10929
|
};
|
|
8487
10930
|
};
|
|
10931
|
+
/**
|
|
10932
|
+
* ### Required permissions
|
|
10933
|
+
* > [
|
|
10934
|
+
* {
|
|
10935
|
+
* "actions": [
|
|
10936
|
+
* "datasets:write"
|
|
10937
|
+
* ],
|
|
10938
|
+
* "datasets": [
|
|
10939
|
+
* {
|
|
10940
|
+
* "params": "dataset_id"
|
|
10941
|
+
* }
|
|
10942
|
+
* ]
|
|
10943
|
+
* }
|
|
10944
|
+
* ]
|
|
10945
|
+
*/
|
|
8488
10946
|
MergeClusters: {
|
|
8489
10947
|
parameters: {
|
|
8490
10948
|
path: {
|
|
@@ -8506,6 +10964,22 @@ export interface operations {
|
|
|
8506
10964
|
};
|
|
8507
10965
|
};
|
|
8508
10966
|
};
|
|
10967
|
+
/**
|
|
10968
|
+
* ### Required permissions
|
|
10969
|
+
* > [
|
|
10970
|
+
* {
|
|
10971
|
+
* "actions": [
|
|
10972
|
+
* "datasets:read",
|
|
10973
|
+
* "datasets:write"
|
|
10974
|
+
* ],
|
|
10975
|
+
* "datasets": [
|
|
10976
|
+
* {
|
|
10977
|
+
* "params": "dataset_id"
|
|
10978
|
+
* }
|
|
10979
|
+
* ]
|
|
10980
|
+
* }
|
|
10981
|
+
* ]
|
|
10982
|
+
*/
|
|
8509
10983
|
CreateClusterSummaries: {
|
|
8510
10984
|
parameters: {
|
|
8511
10985
|
path: {
|
|
@@ -8527,6 +11001,21 @@ export interface operations {
|
|
|
8527
11001
|
};
|
|
8528
11002
|
};
|
|
8529
11003
|
};
|
|
11004
|
+
/**
|
|
11005
|
+
* ### Required permissions
|
|
11006
|
+
* > [
|
|
11007
|
+
* {
|
|
11008
|
+
* "actions": [
|
|
11009
|
+
* "datasets:read"
|
|
11010
|
+
* ],
|
|
11011
|
+
* "datasets": [
|
|
11012
|
+
* {
|
|
11013
|
+
* "params": "dataset_id"
|
|
11014
|
+
* }
|
|
11015
|
+
* ]
|
|
11016
|
+
* }
|
|
11017
|
+
* ]
|
|
11018
|
+
*/
|
|
8530
11019
|
ListClusterSummaries: {
|
|
8531
11020
|
parameters: {
|
|
8532
11021
|
path: {
|
|
@@ -8548,6 +11037,21 @@ export interface operations {
|
|
|
8548
11037
|
};
|
|
8549
11038
|
};
|
|
8550
11039
|
};
|
|
11040
|
+
/**
|
|
11041
|
+
* ### Required permissions
|
|
11042
|
+
* > [
|
|
11043
|
+
* {
|
|
11044
|
+
* "actions": [
|
|
11045
|
+
* "datasets:write"
|
|
11046
|
+
* ],
|
|
11047
|
+
* "datasets": [
|
|
11048
|
+
* {
|
|
11049
|
+
* "params": "dataset_id"
|
|
11050
|
+
* }
|
|
11051
|
+
* ]
|
|
11052
|
+
* }
|
|
11053
|
+
* ]
|
|
11054
|
+
*/
|
|
8551
11055
|
DeleteClusterSummaries: {
|
|
8552
11056
|
parameters: {
|
|
8553
11057
|
path: {
|
|
@@ -8569,6 +11073,10 @@ export interface operations {
|
|
|
8569
11073
|
};
|
|
8570
11074
|
};
|
|
8571
11075
|
};
|
|
11076
|
+
/**
|
|
11077
|
+
* ### Required permissions
|
|
11078
|
+
* > []
|
|
11079
|
+
*/
|
|
8572
11080
|
CreateOrganization: {
|
|
8573
11081
|
parameters: {};
|
|
8574
11082
|
responses: {
|
|
@@ -8585,6 +11093,21 @@ export interface operations {
|
|
|
8585
11093
|
};
|
|
8586
11094
|
};
|
|
8587
11095
|
};
|
|
11096
|
+
/**
|
|
11097
|
+
* ### Required permissions
|
|
11098
|
+
* > [
|
|
11099
|
+
* {
|
|
11100
|
+
* "actions": [
|
|
11101
|
+
* "organizations:write"
|
|
11102
|
+
* ],
|
|
11103
|
+
* "organizations": [
|
|
11104
|
+
* {
|
|
11105
|
+
* "params": "organization_id"
|
|
11106
|
+
* }
|
|
11107
|
+
* ]
|
|
11108
|
+
* }
|
|
11109
|
+
* ]
|
|
11110
|
+
*/
|
|
8588
11111
|
UpdateOrganization: {
|
|
8589
11112
|
parameters: {
|
|
8590
11113
|
path: {
|
|
@@ -8606,6 +11129,21 @@ export interface operations {
|
|
|
8606
11129
|
};
|
|
8607
11130
|
};
|
|
8608
11131
|
};
|
|
11132
|
+
/**
|
|
11133
|
+
* ### Required permissions
|
|
11134
|
+
* > [
|
|
11135
|
+
* {
|
|
11136
|
+
* "actions": [
|
|
11137
|
+
* "support:write"
|
|
11138
|
+
* ],
|
|
11139
|
+
* "organizations": [
|
|
11140
|
+
* {
|
|
11141
|
+
* "params": "organization_id"
|
|
11142
|
+
* }
|
|
11143
|
+
* ]
|
|
11144
|
+
* }
|
|
11145
|
+
* ]
|
|
11146
|
+
*/
|
|
8609
11147
|
UpdateOrganizationAdmin: {
|
|
8610
11148
|
parameters: {
|
|
8611
11149
|
path: {
|
|
@@ -8627,7 +11165,18 @@ export interface operations {
|
|
|
8627
11165
|
};
|
|
8628
11166
|
};
|
|
8629
11167
|
};
|
|
8630
|
-
/**
|
|
11168
|
+
/**
|
|
11169
|
+
* List all organizations and their metadata
|
|
11170
|
+
*
|
|
11171
|
+
* ### Required permissions
|
|
11172
|
+
* > [
|
|
11173
|
+
* {
|
|
11174
|
+
* "actions": [
|
|
11175
|
+
* "organizations:read"
|
|
11176
|
+
* ]
|
|
11177
|
+
* }
|
|
11178
|
+
* ]
|
|
11179
|
+
*/
|
|
8631
11180
|
ListOrganizations: {
|
|
8632
11181
|
parameters: {};
|
|
8633
11182
|
responses: {
|
|
@@ -8639,6 +11188,21 @@ export interface operations {
|
|
|
8639
11188
|
};
|
|
8640
11189
|
};
|
|
8641
11190
|
};
|
|
11191
|
+
/**
|
|
11192
|
+
* ### Required permissions
|
|
11193
|
+
* > [
|
|
11194
|
+
* {
|
|
11195
|
+
* "actions": [
|
|
11196
|
+
* "organizations:write"
|
|
11197
|
+
* ],
|
|
11198
|
+
* "organizations": [
|
|
11199
|
+
* {
|
|
11200
|
+
* "params": "organization_id"
|
|
11201
|
+
* }
|
|
11202
|
+
* ]
|
|
11203
|
+
* }
|
|
11204
|
+
* ]
|
|
11205
|
+
*/
|
|
8642
11206
|
DeleteOrganization: {
|
|
8643
11207
|
parameters: {
|
|
8644
11208
|
path: {
|
|
@@ -8660,6 +11224,21 @@ export interface operations {
|
|
|
8660
11224
|
};
|
|
8661
11225
|
};
|
|
8662
11226
|
};
|
|
11227
|
+
/**
|
|
11228
|
+
* ### Required permissions
|
|
11229
|
+
* > [
|
|
11230
|
+
* {
|
|
11231
|
+
* "actions": [
|
|
11232
|
+
* "organizations:read"
|
|
11233
|
+
* ],
|
|
11234
|
+
* "organizations": [
|
|
11235
|
+
* {
|
|
11236
|
+
* "params": "organization_id"
|
|
11237
|
+
* }
|
|
11238
|
+
* ]
|
|
11239
|
+
* }
|
|
11240
|
+
* ]
|
|
11241
|
+
*/
|
|
8663
11242
|
GetOrganization: {
|
|
8664
11243
|
parameters: {
|
|
8665
11244
|
path: {
|
|
@@ -8676,6 +11255,21 @@ export interface operations {
|
|
|
8676
11255
|
};
|
|
8677
11256
|
};
|
|
8678
11257
|
};
|
|
11258
|
+
/**
|
|
11259
|
+
* ### Required permissions
|
|
11260
|
+
* > [
|
|
11261
|
+
* {
|
|
11262
|
+
* "actions": [
|
|
11263
|
+
* "organizations:read"
|
|
11264
|
+
* ],
|
|
11265
|
+
* "organizations": [
|
|
11266
|
+
* {
|
|
11267
|
+
* "params": "organization_id"
|
|
11268
|
+
* }
|
|
11269
|
+
* ]
|
|
11270
|
+
* }
|
|
11271
|
+
* ]
|
|
11272
|
+
*/
|
|
8679
11273
|
GetOrganizationUsage: {
|
|
8680
11274
|
parameters: {
|
|
8681
11275
|
path: {
|
|
@@ -8692,6 +11286,21 @@ export interface operations {
|
|
|
8692
11286
|
};
|
|
8693
11287
|
};
|
|
8694
11288
|
};
|
|
11289
|
+
/**
|
|
11290
|
+
* ### Required permissions
|
|
11291
|
+
* > [
|
|
11292
|
+
* {
|
|
11293
|
+
* "actions": [
|
|
11294
|
+
* "organizations:read"
|
|
11295
|
+
* ],
|
|
11296
|
+
* "organizations": [
|
|
11297
|
+
* {
|
|
11298
|
+
* "params": "organization_id"
|
|
11299
|
+
* }
|
|
11300
|
+
* ]
|
|
11301
|
+
* }
|
|
11302
|
+
* ]
|
|
11303
|
+
*/
|
|
8695
11304
|
ListUsersInOrganization: {
|
|
8696
11305
|
parameters: {
|
|
8697
11306
|
path: {
|
|
@@ -8708,6 +11317,21 @@ export interface operations {
|
|
|
8708
11317
|
};
|
|
8709
11318
|
};
|
|
8710
11319
|
};
|
|
11320
|
+
/**
|
|
11321
|
+
* ### Required permissions
|
|
11322
|
+
* > [
|
|
11323
|
+
* {
|
|
11324
|
+
* "actions": [
|
|
11325
|
+
* "organizations:read"
|
|
11326
|
+
* ],
|
|
11327
|
+
* "organizations": [
|
|
11328
|
+
* {
|
|
11329
|
+
* "params": "organization_id"
|
|
11330
|
+
* }
|
|
11331
|
+
* ]
|
|
11332
|
+
* }
|
|
11333
|
+
* ]
|
|
11334
|
+
*/
|
|
8711
11335
|
ListProjectsInOrganization: {
|
|
8712
11336
|
parameters: {
|
|
8713
11337
|
path: {
|
|
@@ -8733,6 +11357,21 @@ export interface operations {
|
|
|
8733
11357
|
*
|
|
8734
11358
|
* If inserting many items in a short timespan, use bulkInsert, or set update_schema to false.
|
|
8735
11359
|
* Every insert api call temporarily locks and updates the schema, so will slow down with many inserts in quick succession.
|
|
11360
|
+
*
|
|
11361
|
+
*
|
|
11362
|
+
* ### Required permissions
|
|
11363
|
+
* > [
|
|
11364
|
+
* {
|
|
11365
|
+
* "actions": [
|
|
11366
|
+
* "datasets:write"
|
|
11367
|
+
* ],
|
|
11368
|
+
* "datasets": [
|
|
11369
|
+
* {
|
|
11370
|
+
* "params": "dataset_id"
|
|
11371
|
+
* }
|
|
11372
|
+
* ]
|
|
11373
|
+
* }
|
|
11374
|
+
* ]
|
|
8736
11375
|
*/
|
|
8737
11376
|
Insert: {
|
|
8738
11377
|
parameters: {
|
|
@@ -8768,6 +11407,21 @@ export interface operations {
|
|
|
8768
11407
|
* If the provided dataset doesn't exist, one will be automatically created.
|
|
8769
11408
|
*
|
|
8770
11409
|
* Limit the payload of documents to a maximum 100MB for optimal performance.
|
|
11410
|
+
*
|
|
11411
|
+
*
|
|
11412
|
+
* ### Required permissions
|
|
11413
|
+
* > [
|
|
11414
|
+
* {
|
|
11415
|
+
* "actions": [
|
|
11416
|
+
* "datasets:write"
|
|
11417
|
+
* ],
|
|
11418
|
+
* "datasets": [
|
|
11419
|
+
* {
|
|
11420
|
+
* "params": "dataset_id"
|
|
11421
|
+
* }
|
|
11422
|
+
* ]
|
|
11423
|
+
* }
|
|
11424
|
+
* ]
|
|
8771
11425
|
*/
|
|
8772
11426
|
BulkInsert: {
|
|
8773
11427
|
parameters: {
|
|
@@ -8790,7 +11444,23 @@ export interface operations {
|
|
|
8790
11444
|
};
|
|
8791
11445
|
};
|
|
8792
11446
|
};
|
|
8793
|
-
/**
|
|
11447
|
+
/**
|
|
11448
|
+
* specify a list of file paths. For each file path, a url upload_url is returned. files can be POSTed on upload_url to upload them. They can then be accessed on url. Upon dataset deletion, these files will be deleted.
|
|
11449
|
+
*
|
|
11450
|
+
* ### Required permissions
|
|
11451
|
+
* > [
|
|
11452
|
+
* {
|
|
11453
|
+
* "actions": [
|
|
11454
|
+
* "datasets:write"
|
|
11455
|
+
* ],
|
|
11456
|
+
* "datasets": [
|
|
11457
|
+
* {
|
|
11458
|
+
* "params": "dataset_id"
|
|
11459
|
+
* }
|
|
11460
|
+
* ]
|
|
11461
|
+
* }
|
|
11462
|
+
* ]
|
|
11463
|
+
*/
|
|
8794
11464
|
GetFileUploadUrlsForDataset: {
|
|
8795
11465
|
parameters: {
|
|
8796
11466
|
path: {
|
|
@@ -8812,7 +11482,23 @@ export interface operations {
|
|
|
8812
11482
|
};
|
|
8813
11483
|
};
|
|
8814
11484
|
};
|
|
8815
|
-
/**
|
|
11485
|
+
/**
|
|
11486
|
+
* Return up to 1000 files uploaded for a dataset.
|
|
11487
|
+
*
|
|
11488
|
+
* ### Required permissions
|
|
11489
|
+
* > [
|
|
11490
|
+
* {
|
|
11491
|
+
* "actions": [
|
|
11492
|
+
* "datasets:read"
|
|
11493
|
+
* ],
|
|
11494
|
+
* "datasets": [
|
|
11495
|
+
* {
|
|
11496
|
+
* "params": "dataset_id"
|
|
11497
|
+
* }
|
|
11498
|
+
* ]
|
|
11499
|
+
* }
|
|
11500
|
+
* ]
|
|
11501
|
+
*/
|
|
8816
11502
|
ListFileUploadsForDataset: {
|
|
8817
11503
|
parameters: {
|
|
8818
11504
|
path: {
|
|
@@ -8829,7 +11515,23 @@ export interface operations {
|
|
|
8829
11515
|
};
|
|
8830
11516
|
};
|
|
8831
11517
|
};
|
|
8832
|
-
/**
|
|
11518
|
+
/**
|
|
11519
|
+
* Bulk insert a large number of documents by downloading a file using "download url". This bypasses the need to directly send documents to the api, as happens in BulkInsert.
|
|
11520
|
+
*
|
|
11521
|
+
* ### Required permissions
|
|
11522
|
+
* > [
|
|
11523
|
+
* {
|
|
11524
|
+
* "actions": [
|
|
11525
|
+
* "datasets:write"
|
|
11526
|
+
* ],
|
|
11527
|
+
* "datasets": [
|
|
11528
|
+
* {
|
|
11529
|
+
* "params": "dataset_id"
|
|
11530
|
+
* }
|
|
11531
|
+
* ]
|
|
11532
|
+
* }
|
|
11533
|
+
* ]
|
|
11534
|
+
*/
|
|
8833
11535
|
ParseBlob: {
|
|
8834
11536
|
parameters: {
|
|
8835
11537
|
path: {
|
|
@@ -8851,7 +11553,12 @@ export interface operations {
|
|
|
8851
11553
|
};
|
|
8852
11554
|
};
|
|
8853
11555
|
};
|
|
8854
|
-
/**
|
|
11556
|
+
/**
|
|
11557
|
+
* Copy a dataset from another users projects into your project. This is considered a project job.
|
|
11558
|
+
*
|
|
11559
|
+
* ### Required permissions
|
|
11560
|
+
* > []
|
|
11561
|
+
*/
|
|
8855
11562
|
CopyForeignDataset: {
|
|
8856
11563
|
parameters: {};
|
|
8857
11564
|
responses: {
|
|
@@ -8868,7 +11575,24 @@ export interface operations {
|
|
|
8868
11575
|
};
|
|
8869
11576
|
};
|
|
8870
11577
|
};
|
|
8871
|
-
/**
|
|
11578
|
+
/**
|
|
11579
|
+
* Creates a read only key for your project. Make sure to save the api key somewhere safe. When doing a search the admin username should still be used.
|
|
11580
|
+
*
|
|
11581
|
+
* ### Required permissions
|
|
11582
|
+
* > [
|
|
11583
|
+
* {
|
|
11584
|
+
* "actions": [
|
|
11585
|
+
* "users:write",
|
|
11586
|
+
* "datasets:read"
|
|
11587
|
+
* ],
|
|
11588
|
+
* "datasets": [
|
|
11589
|
+
* {
|
|
11590
|
+
* "raw": "*"
|
|
11591
|
+
* }
|
|
11592
|
+
* ]
|
|
11593
|
+
* }
|
|
11594
|
+
* ]
|
|
11595
|
+
*/
|
|
8872
11596
|
CreateProjectReadKey: {
|
|
8873
11597
|
parameters: {};
|
|
8874
11598
|
responses: {
|
|
@@ -8885,7 +11609,23 @@ export interface operations {
|
|
|
8885
11609
|
};
|
|
8886
11610
|
};
|
|
8887
11611
|
};
|
|
8888
|
-
/**
|
|
11612
|
+
/**
|
|
11613
|
+
* Delete a dataset.
|
|
11614
|
+
*
|
|
11615
|
+
* ### Required permissions
|
|
11616
|
+
* > [
|
|
11617
|
+
* {
|
|
11618
|
+
* "actions": [
|
|
11619
|
+
* "datasets:write"
|
|
11620
|
+
* ],
|
|
11621
|
+
* "datasets": [
|
|
11622
|
+
* {
|
|
11623
|
+
* "params": "dataset_id"
|
|
11624
|
+
* }
|
|
11625
|
+
* ]
|
|
11626
|
+
* }
|
|
11627
|
+
* ]
|
|
11628
|
+
*/
|
|
8889
11629
|
DeleteDataset: {
|
|
8890
11630
|
parameters: {
|
|
8891
11631
|
path: {
|
|
@@ -8941,6 +11681,23 @@ export interface operations {
|
|
|
8941
11681
|
*
|
|
8942
11682
|
* For more information about vectors check out the 'Vectorizing' section, **\/services/search/vector** or out blog at [https://relevance.ai/blog](https://relevance.ai/blog).
|
|
8943
11683
|
* For more information about chunks and chunk vectors check out **\/services/search/chunk**.
|
|
11684
|
+
*
|
|
11685
|
+
*
|
|
11686
|
+
*
|
|
11687
|
+
*
|
|
11688
|
+
* ### Required permissions
|
|
11689
|
+
* > [
|
|
11690
|
+
* {
|
|
11691
|
+
* "actions": [
|
|
11692
|
+
* "datasets:write"
|
|
11693
|
+
* ],
|
|
11694
|
+
* "datasets": [
|
|
11695
|
+
* {
|
|
11696
|
+
* "body": "id"
|
|
11697
|
+
* }
|
|
11698
|
+
* ]
|
|
11699
|
+
* }
|
|
11700
|
+
* ]
|
|
8944
11701
|
*/
|
|
8945
11702
|
CreateDataset: {
|
|
8946
11703
|
parameters: {};
|
|
@@ -8958,6 +11715,21 @@ export interface operations {
|
|
|
8958
11715
|
};
|
|
8959
11716
|
};
|
|
8960
11717
|
};
|
|
11718
|
+
/**
|
|
11719
|
+
* ### Required permissions
|
|
11720
|
+
* > [
|
|
11721
|
+
* {
|
|
11722
|
+
* "actions": [
|
|
11723
|
+
* "datasets:read"
|
|
11724
|
+
* ],
|
|
11725
|
+
* "datasets": [
|
|
11726
|
+
* {
|
|
11727
|
+
* "params": "dataset_id"
|
|
11728
|
+
* }
|
|
11729
|
+
* ]
|
|
11730
|
+
* }
|
|
11731
|
+
* ]
|
|
11732
|
+
*/
|
|
8961
11733
|
GetSchema: {
|
|
8962
11734
|
parameters: {
|
|
8963
11735
|
path: {
|
|
@@ -8974,7 +11746,16 @@ export interface operations {
|
|
|
8974
11746
|
};
|
|
8975
11747
|
};
|
|
8976
11748
|
};
|
|
8977
|
-
/**
|
|
11749
|
+
/**
|
|
11750
|
+
* List all datasets in a project that you are authorized to read/write.
|
|
11751
|
+
*
|
|
11752
|
+
* ### Required permissions
|
|
11753
|
+
* > [
|
|
11754
|
+
* {
|
|
11755
|
+
* "actions": []
|
|
11756
|
+
* }
|
|
11757
|
+
* ]
|
|
11758
|
+
*/
|
|
8978
11759
|
ListDatasets: {
|
|
8979
11760
|
parameters: {};
|
|
8980
11761
|
responses: {
|
|
@@ -8986,6 +11767,31 @@ export interface operations {
|
|
|
8986
11767
|
};
|
|
8987
11768
|
};
|
|
8988
11769
|
};
|
|
11770
|
+
/**
|
|
11771
|
+
* ### Required permissions
|
|
11772
|
+
* > [
|
|
11773
|
+
* {
|
|
11774
|
+
* "actions": [
|
|
11775
|
+
* "datasets:read"
|
|
11776
|
+
* ],
|
|
11777
|
+
* "datasets": [
|
|
11778
|
+
* {
|
|
11779
|
+
* "body": "dataset_ids"
|
|
11780
|
+
* }
|
|
11781
|
+
* ]
|
|
11782
|
+
* },
|
|
11783
|
+
* {
|
|
11784
|
+
* "actions": [
|
|
11785
|
+
* "datasets:write"
|
|
11786
|
+
* ],
|
|
11787
|
+
* "datasets": [
|
|
11788
|
+
* {
|
|
11789
|
+
* "body": "new_dataset_id"
|
|
11790
|
+
* }
|
|
11791
|
+
* ]
|
|
11792
|
+
* }
|
|
11793
|
+
* ]
|
|
11794
|
+
*/
|
|
8989
11795
|
CombineDatasets: {
|
|
8990
11796
|
parameters: {};
|
|
8991
11797
|
responses: {
|
|
@@ -9002,6 +11808,10 @@ export interface operations {
|
|
|
9002
11808
|
};
|
|
9003
11809
|
};
|
|
9004
11810
|
};
|
|
11811
|
+
/**
|
|
11812
|
+
* ### Required permissions
|
|
11813
|
+
* > []
|
|
11814
|
+
*/
|
|
9005
11815
|
GetCombineJobStatus: {
|
|
9006
11816
|
parameters: {
|
|
9007
11817
|
path: {
|
|
@@ -9023,7 +11833,16 @@ export interface operations {
|
|
|
9023
11833
|
};
|
|
9024
11834
|
};
|
|
9025
11835
|
};
|
|
9026
|
-
/**
|
|
11836
|
+
/**
|
|
11837
|
+
* Search all datasets in a project that you are authorized to read/write.
|
|
11838
|
+
*
|
|
11839
|
+
* ### Required permissions
|
|
11840
|
+
* > [
|
|
11841
|
+
* {
|
|
11842
|
+
* "actions": []
|
|
11843
|
+
* }
|
|
11844
|
+
* ]
|
|
11845
|
+
*/
|
|
9027
11846
|
SearchDatasets: {
|
|
9028
11847
|
parameters: {
|
|
9029
11848
|
query: {
|
|
@@ -9044,7 +11863,23 @@ export interface operations {
|
|
|
9044
11863
|
};
|
|
9045
11864
|
};
|
|
9046
11865
|
};
|
|
9047
|
-
/**
|
|
11866
|
+
/**
|
|
11867
|
+
* Gives you a summary of the health of your vectors, e.g. how many documents with vectors are missing, how many documents with zero vectors
|
|
11868
|
+
*
|
|
11869
|
+
* ### Required permissions
|
|
11870
|
+
* > [
|
|
11871
|
+
* {
|
|
11872
|
+
* "actions": [
|
|
11873
|
+
* "datasets:read"
|
|
11874
|
+
* ],
|
|
11875
|
+
* "datasets": [
|
|
11876
|
+
* {
|
|
11877
|
+
* "params": "dataset_id"
|
|
11878
|
+
* }
|
|
11879
|
+
* ]
|
|
11880
|
+
* }
|
|
11881
|
+
* ]
|
|
11882
|
+
*/
|
|
9048
11883
|
GetFieldHealth: {
|
|
9049
11884
|
parameters: {
|
|
9050
11885
|
path: {
|
|
@@ -9061,7 +11896,23 @@ export interface operations {
|
|
|
9061
11896
|
};
|
|
9062
11897
|
};
|
|
9063
11898
|
};
|
|
9064
|
-
/**
|
|
11899
|
+
/**
|
|
11900
|
+
* View the usage statistics of a dataset.
|
|
11901
|
+
*
|
|
11902
|
+
* ### Required permissions
|
|
11903
|
+
* > [
|
|
11904
|
+
* {
|
|
11905
|
+
* "actions": [
|
|
11906
|
+
* "datasets:read"
|
|
11907
|
+
* ],
|
|
11908
|
+
* "datasets": [
|
|
11909
|
+
* {
|
|
11910
|
+
* "params": "dataset_id"
|
|
11911
|
+
* }
|
|
11912
|
+
* ]
|
|
11913
|
+
* }
|
|
11914
|
+
* ]
|
|
11915
|
+
*/
|
|
9065
11916
|
GetDatasetStats: {
|
|
9066
11917
|
parameters: {
|
|
9067
11918
|
path: {
|
|
@@ -9078,7 +11929,23 @@ export interface operations {
|
|
|
9078
11929
|
};
|
|
9079
11930
|
};
|
|
9080
11931
|
};
|
|
9081
|
-
/**
|
|
11932
|
+
/**
|
|
11933
|
+
* View api call usage statistics for a dataset.
|
|
11934
|
+
*
|
|
11935
|
+
* ### Required permissions
|
|
11936
|
+
* > [
|
|
11937
|
+
* {
|
|
11938
|
+
* "actions": [
|
|
11939
|
+
* "datasets:read"
|
|
11940
|
+
* ],
|
|
11941
|
+
* "datasets": [
|
|
11942
|
+
* {
|
|
11943
|
+
* "params": "dataset_id"
|
|
11944
|
+
* }
|
|
11945
|
+
* ]
|
|
11946
|
+
* }
|
|
11947
|
+
* ]
|
|
11948
|
+
*/
|
|
9082
11949
|
GetDatasetUsage: {
|
|
9083
11950
|
parameters: {
|
|
9084
11951
|
path: {
|
|
@@ -9100,7 +11967,23 @@ export interface operations {
|
|
|
9100
11967
|
};
|
|
9101
11968
|
};
|
|
9102
11969
|
};
|
|
9103
|
-
/**
|
|
11970
|
+
/**
|
|
11971
|
+
* DEPRECATED !!!! Retrieve the mapping of vectors generated through fields, dictionary, array, etc
|
|
11972
|
+
*
|
|
11973
|
+
* ### Required permissions
|
|
11974
|
+
* > [
|
|
11975
|
+
* {
|
|
11976
|
+
* "actions": [
|
|
11977
|
+
* "datasets:read"
|
|
11978
|
+
* ],
|
|
11979
|
+
* "datasets": [
|
|
11980
|
+
* {
|
|
11981
|
+
* "params": "dataset_id"
|
|
11982
|
+
* }
|
|
11983
|
+
* ]
|
|
11984
|
+
* }
|
|
11985
|
+
* ]
|
|
11986
|
+
*/
|
|
9104
11987
|
GetVectorMappings: {
|
|
9105
11988
|
parameters: {
|
|
9106
11989
|
path: {
|
|
@@ -9128,6 +12011,21 @@ export interface operations {
|
|
|
9128
12011
|
* | vector_health | Number of zero vectors stored. (returns same data as **\/dataset/{dataset_id}/monitor/health**) |
|
|
9129
12012
|
* | schema_stats | Fields and number of documents missing/not missing for that field. (returns same data as **\/dataset/{dataset_id}/monitor/stats**) |
|
|
9130
12013
|
* | active_jobs | All active jobs/tasks on the dataset. (returns same data as **\/dataset/{dataset_id}/tasks/list**) |
|
|
12014
|
+
*
|
|
12015
|
+
*
|
|
12016
|
+
* ### Required permissions
|
|
12017
|
+
* > [
|
|
12018
|
+
* {
|
|
12019
|
+
* "actions": [
|
|
12020
|
+
* "datasets:read"
|
|
12021
|
+
* ],
|
|
12022
|
+
* "datasets": [
|
|
12023
|
+
* {
|
|
12024
|
+
* "params": "dataset_id"
|
|
12025
|
+
* }
|
|
12026
|
+
* ]
|
|
12027
|
+
* }
|
|
12028
|
+
* ]
|
|
9131
12029
|
*/
|
|
9132
12030
|
GetDatasetDetails: {
|
|
9133
12031
|
parameters: {
|
|
@@ -9154,6 +12052,21 @@ export interface operations {
|
|
|
9154
12052
|
* Retrieve a document by its `_id`.
|
|
9155
12053
|
*
|
|
9156
12054
|
* This is the most performant method to get a document or check if it exists, faster than filtering a dataset for by an `_id`.
|
|
12055
|
+
*
|
|
12056
|
+
*
|
|
12057
|
+
* ### Required permissions
|
|
12058
|
+
* > [
|
|
12059
|
+
* {
|
|
12060
|
+
* "actions": [
|
|
12061
|
+
* "datasets:read"
|
|
12062
|
+
* ],
|
|
12063
|
+
* "datasets": [
|
|
12064
|
+
* {
|
|
12065
|
+
* "params": "dataset_id"
|
|
12066
|
+
* }
|
|
12067
|
+
* ]
|
|
12068
|
+
* }
|
|
12069
|
+
* ]
|
|
9157
12070
|
*/
|
|
9158
12071
|
GetDocument: {
|
|
9159
12072
|
parameters: {
|
|
@@ -9181,6 +12094,21 @@ export interface operations {
|
|
|
9181
12094
|
* Delete a document by its `_id` and remove it from the dataset.
|
|
9182
12095
|
*
|
|
9183
12096
|
* Support for deleting many documents at once is available through [`/bulk_delete`](/reference/bulk_delete_api_datasets__dataset_id__documents_bulk_delete_post).
|
|
12097
|
+
*
|
|
12098
|
+
*
|
|
12099
|
+
* ### Required permissions
|
|
12100
|
+
* > [
|
|
12101
|
+
* {
|
|
12102
|
+
* "actions": [
|
|
12103
|
+
* "datasets:write"
|
|
12104
|
+
* ],
|
|
12105
|
+
* "datasets": [
|
|
12106
|
+
* {
|
|
12107
|
+
* "params": "dataset_id"
|
|
12108
|
+
* }
|
|
12109
|
+
* ]
|
|
12110
|
+
* }
|
|
12111
|
+
* ]
|
|
9184
12112
|
*/
|
|
9185
12113
|
DeleteDocument: {
|
|
9186
12114
|
parameters: {
|
|
@@ -9203,7 +12131,23 @@ export interface operations {
|
|
|
9203
12131
|
};
|
|
9204
12132
|
};
|
|
9205
12133
|
};
|
|
9206
|
-
/**
|
|
12134
|
+
/**
|
|
12135
|
+
* Retreives settings for dataset.
|
|
12136
|
+
*
|
|
12137
|
+
* ### Required permissions
|
|
12138
|
+
* > [
|
|
12139
|
+
* {
|
|
12140
|
+
* "actions": [
|
|
12141
|
+
* "datasets:read"
|
|
12142
|
+
* ],
|
|
12143
|
+
* "datasets": [
|
|
12144
|
+
* {
|
|
12145
|
+
* "params": "dataset_id"
|
|
12146
|
+
* }
|
|
12147
|
+
* ]
|
|
12148
|
+
* }
|
|
12149
|
+
* ]
|
|
12150
|
+
*/
|
|
9207
12151
|
GetDatasetSettings: {
|
|
9208
12152
|
parameters: {
|
|
9209
12153
|
path: {
|
|
@@ -9220,7 +12164,23 @@ export interface operations {
|
|
|
9220
12164
|
};
|
|
9221
12165
|
};
|
|
9222
12166
|
};
|
|
9223
|
-
/**
|
|
12167
|
+
/**
|
|
12168
|
+
* Add and overwrite settings about a dataset. Notably description, data source, etc.
|
|
12169
|
+
*
|
|
12170
|
+
* ### Required permissions
|
|
12171
|
+
* > [
|
|
12172
|
+
* {
|
|
12173
|
+
* "actions": [
|
|
12174
|
+
* "datasets:write"
|
|
12175
|
+
* ],
|
|
12176
|
+
* "datasets": [
|
|
12177
|
+
* {
|
|
12178
|
+
* "params": "dataset_id"
|
|
12179
|
+
* }
|
|
12180
|
+
* ]
|
|
12181
|
+
* }
|
|
12182
|
+
* ]
|
|
12183
|
+
*/
|
|
9224
12184
|
UpsertDatasetSettings: {
|
|
9225
12185
|
parameters: {
|
|
9226
12186
|
path: {
|
|
@@ -9242,7 +12202,23 @@ export interface operations {
|
|
|
9242
12202
|
};
|
|
9243
12203
|
};
|
|
9244
12204
|
};
|
|
9245
|
-
/**
|
|
12205
|
+
/**
|
|
12206
|
+
* Retreives metadata about a dataset. Notably description, data source, etc
|
|
12207
|
+
*
|
|
12208
|
+
* ### Required permissions
|
|
12209
|
+
* > [
|
|
12210
|
+
* {
|
|
12211
|
+
* "actions": [
|
|
12212
|
+
* "datasets:read"
|
|
12213
|
+
* ],
|
|
12214
|
+
* "datasets": [
|
|
12215
|
+
* {
|
|
12216
|
+
* "params": "dataset_id"
|
|
12217
|
+
* }
|
|
12218
|
+
* ]
|
|
12219
|
+
* }
|
|
12220
|
+
* ]
|
|
12221
|
+
*/
|
|
9246
12222
|
GetDatasetMetadata: {
|
|
9247
12223
|
parameters: {
|
|
9248
12224
|
path: {
|
|
@@ -9259,7 +12235,23 @@ export interface operations {
|
|
|
9259
12235
|
};
|
|
9260
12236
|
};
|
|
9261
12237
|
};
|
|
9262
|
-
/**
|
|
12238
|
+
/**
|
|
12239
|
+
* Retreives metadata about a dataset. Notably description, data source, etc
|
|
12240
|
+
*
|
|
12241
|
+
* ### Required permissions
|
|
12242
|
+
* > [
|
|
12243
|
+
* {
|
|
12244
|
+
* "actions": [
|
|
12245
|
+
* "datasets:write"
|
|
12246
|
+
* ],
|
|
12247
|
+
* "datasets": [
|
|
12248
|
+
* {
|
|
12249
|
+
* "params": "dataset_id"
|
|
12250
|
+
* }
|
|
12251
|
+
* ]
|
|
12252
|
+
* }
|
|
12253
|
+
* ]
|
|
12254
|
+
*/
|
|
9263
12255
|
UpsertDatasetMetadata: {
|
|
9264
12256
|
parameters: {
|
|
9265
12257
|
path: {
|
|
@@ -9289,6 +12281,21 @@ export interface operations {
|
|
|
9289
12281
|
* If the provided `_id` has no matching document in the dataset, a new document will be created. Likewise, if the provided `dataset_id` does not match a dataset in your project a new one will be created.
|
|
9290
12282
|
*
|
|
9291
12283
|
* Support for updating many documents at once with a filter condition is available through [`/update_where`](/reference/updatewhere).
|
|
12284
|
+
*
|
|
12285
|
+
*
|
|
12286
|
+
* ### Required permissions
|
|
12287
|
+
* > [
|
|
12288
|
+
* {
|
|
12289
|
+
* "actions": [
|
|
12290
|
+
* "datasets:write"
|
|
12291
|
+
* ],
|
|
12292
|
+
* "datasets": [
|
|
12293
|
+
* {
|
|
12294
|
+
* "params": "dataset_id"
|
|
12295
|
+
* }
|
|
12296
|
+
* ]
|
|
12297
|
+
* }
|
|
12298
|
+
* ]
|
|
9292
12299
|
*/
|
|
9293
12300
|
Update: {
|
|
9294
12301
|
parameters: {
|
|
@@ -9311,7 +12318,23 @@ export interface operations {
|
|
|
9311
12318
|
};
|
|
9312
12319
|
};
|
|
9313
12320
|
};
|
|
9314
|
-
/**
|
|
12321
|
+
/**
|
|
12322
|
+
* Delete fields in a document in a dataset by its id.
|
|
12323
|
+
*
|
|
12324
|
+
* ### Required permissions
|
|
12325
|
+
* > [
|
|
12326
|
+
* {
|
|
12327
|
+
* "actions": [
|
|
12328
|
+
* "datasets:write"
|
|
12329
|
+
* ],
|
|
12330
|
+
* "datasets": [
|
|
12331
|
+
* {
|
|
12332
|
+
* "params": "dataset_id"
|
|
12333
|
+
* }
|
|
12334
|
+
* ]
|
|
12335
|
+
* }
|
|
12336
|
+
* ]
|
|
12337
|
+
*/
|
|
9315
12338
|
DeleteDocumentFields: {
|
|
9316
12339
|
parameters: {
|
|
9317
12340
|
path: {
|
|
@@ -9339,6 +12362,21 @@ export interface operations {
|
|
|
9339
12362
|
* If updating many items in a short timespan, please use BulkUpdate.
|
|
9340
12363
|
*
|
|
9341
12364
|
* Every update api call temporarily locks and updates the schema, so will slow down with many updates in quick succession.
|
|
12365
|
+
*
|
|
12366
|
+
*
|
|
12367
|
+
* ### Required permissions
|
|
12368
|
+
* > [
|
|
12369
|
+
* {
|
|
12370
|
+
* "actions": [
|
|
12371
|
+
* "datasets:write"
|
|
12372
|
+
* ],
|
|
12373
|
+
* "datasets": [
|
|
12374
|
+
* {
|
|
12375
|
+
* "params": "dataset_id"
|
|
12376
|
+
* }
|
|
12377
|
+
* ]
|
|
12378
|
+
* }
|
|
12379
|
+
* ]
|
|
9342
12380
|
*/
|
|
9343
12381
|
BulkUpdate: {
|
|
9344
12382
|
parameters: {
|
|
@@ -9367,6 +12405,21 @@ export interface operations {
|
|
|
9367
12405
|
* This method supports a partial update so you may add new fields or update only those you need. Other fields will remain unaffected.
|
|
9368
12406
|
*
|
|
9369
12407
|
* If the provided `dataset_id` does not match a dataset in your project, a new one will be created.
|
|
12408
|
+
*
|
|
12409
|
+
*
|
|
12410
|
+
* ### Required permissions
|
|
12411
|
+
* > [
|
|
12412
|
+
* {
|
|
12413
|
+
* "actions": [
|
|
12414
|
+
* "datasets:write"
|
|
12415
|
+
* ],
|
|
12416
|
+
* "datasets": [
|
|
12417
|
+
* {
|
|
12418
|
+
* "params": "dataset_id"
|
|
12419
|
+
* }
|
|
12420
|
+
* ]
|
|
12421
|
+
* }
|
|
12422
|
+
* ]
|
|
9370
12423
|
*/
|
|
9371
12424
|
UpdateWhere: {
|
|
9372
12425
|
parameters: {
|
|
@@ -9389,7 +12442,23 @@ export interface operations {
|
|
|
9389
12442
|
};
|
|
9390
12443
|
};
|
|
9391
12444
|
};
|
|
9392
|
-
/**
|
|
12445
|
+
/**
|
|
12446
|
+
* Takes a high level aggregation of every field, return their unique values and frequencies. This is used to help create the filter bar for search.
|
|
12447
|
+
*
|
|
12448
|
+
* ### Required permissions
|
|
12449
|
+
* > [
|
|
12450
|
+
* {
|
|
12451
|
+
* "actions": [
|
|
12452
|
+
* "datasets:read"
|
|
12453
|
+
* ],
|
|
12454
|
+
* "datasets": [
|
|
12455
|
+
* {
|
|
12456
|
+
* "params": "dataset_id"
|
|
12457
|
+
* }
|
|
12458
|
+
* ]
|
|
12459
|
+
* }
|
|
12460
|
+
* ]
|
|
12461
|
+
*/
|
|
9393
12462
|
ListFacets: {
|
|
9394
12463
|
parameters: {
|
|
9395
12464
|
path: {
|
|
@@ -9415,6 +12484,20 @@ export interface operations {
|
|
|
9415
12484
|
* Retrieve documents with filters.
|
|
9416
12485
|
* afterId is provided to retrieve even more documents. Loop through it to retrieve all documents in the database.
|
|
9417
12486
|
* Filter is used to retrieve documents that match the conditions set in a filter query.
|
|
12487
|
+
*
|
|
12488
|
+
* ### Required permissions
|
|
12489
|
+
* > [
|
|
12490
|
+
* {
|
|
12491
|
+
* "actions": [
|
|
12492
|
+
* "datasets:read"
|
|
12493
|
+
* ],
|
|
12494
|
+
* "datasets": [
|
|
12495
|
+
* {
|
|
12496
|
+
* "params": "dataset_id"
|
|
12497
|
+
* }
|
|
12498
|
+
* ]
|
|
12499
|
+
* }
|
|
12500
|
+
* ]
|
|
9418
12501
|
*/
|
|
9419
12502
|
GetWhere: {
|
|
9420
12503
|
parameters: {
|
|
@@ -9441,6 +12524,20 @@ export interface operations {
|
|
|
9441
12524
|
* Retrieve documents with filters.
|
|
9442
12525
|
* afterId is provided to retrieve even more documents. Loop through it to retrieve all documents in the database.
|
|
9443
12526
|
* Filter is used to retrieve documents that match the conditions set in a filter query.
|
|
12527
|
+
*
|
|
12528
|
+
* ### Required permissions
|
|
12529
|
+
* > [
|
|
12530
|
+
* {
|
|
12531
|
+
* "actions": [
|
|
12532
|
+
* "datasets:read"
|
|
12533
|
+
* ],
|
|
12534
|
+
* "datasets": [
|
|
12535
|
+
* {
|
|
12536
|
+
* "params": "dataset_id"
|
|
12537
|
+
* }
|
|
12538
|
+
* ]
|
|
12539
|
+
* }
|
|
12540
|
+
* ]
|
|
9444
12541
|
*/
|
|
9445
12542
|
PaginateDocuments: {
|
|
9446
12543
|
parameters: {
|
|
@@ -9463,7 +12560,23 @@ export interface operations {
|
|
|
9463
12560
|
};
|
|
9464
12561
|
};
|
|
9465
12562
|
};
|
|
9466
|
-
/**
|
|
12563
|
+
/**
|
|
12564
|
+
* Retrieve documents by their IDs ("_id" field). This will retrieve the documents faster than a filter applied on the "_id" field. For single id lookup version of this request use /datasets/{dataset_id}/documents/get.
|
|
12565
|
+
*
|
|
12566
|
+
* ### Required permissions
|
|
12567
|
+
* > [
|
|
12568
|
+
* {
|
|
12569
|
+
* "actions": [
|
|
12570
|
+
* "datasets:read"
|
|
12571
|
+
* ],
|
|
12572
|
+
* "datasets": [
|
|
12573
|
+
* {
|
|
12574
|
+
* "params": "dataset_id"
|
|
12575
|
+
* }
|
|
12576
|
+
* ]
|
|
12577
|
+
* }
|
|
12578
|
+
* ]
|
|
12579
|
+
*/
|
|
9467
12580
|
BulkGetDocuments: {
|
|
9468
12581
|
parameters: {
|
|
9469
12582
|
path: {
|
|
@@ -9485,7 +12598,23 @@ export interface operations {
|
|
|
9485
12598
|
};
|
|
9486
12599
|
};
|
|
9487
12600
|
};
|
|
9488
|
-
/**
|
|
12601
|
+
/**
|
|
12602
|
+
* Delete a list of documents by their IDs. For deleting a single document refer to /datasets/{dataset_id}/documents/delete or deleting documents by filters refer to /datasets/{dataset_id}/documents/delete_where.
|
|
12603
|
+
*
|
|
12604
|
+
* ### Required permissions
|
|
12605
|
+
* > [
|
|
12606
|
+
* {
|
|
12607
|
+
* "actions": [
|
|
12608
|
+
* "datasets:write"
|
|
12609
|
+
* ],
|
|
12610
|
+
* "datasets": [
|
|
12611
|
+
* {
|
|
12612
|
+
* "params": "dataset_id"
|
|
12613
|
+
* }
|
|
12614
|
+
* ]
|
|
12615
|
+
* }
|
|
12616
|
+
* ]
|
|
12617
|
+
*/
|
|
9489
12618
|
BulkDeleteDocuments: {
|
|
9490
12619
|
parameters: {
|
|
9491
12620
|
path: {
|
|
@@ -9511,6 +12640,20 @@ export interface operations {
|
|
|
9511
12640
|
* Retrieve documents with filters.
|
|
9512
12641
|
* afterId is provided to retrieve even more documents. Loop through it to retrieve all documents in the database.
|
|
9513
12642
|
* Filter is used to retrieve documents that match the conditions set in a filter query.
|
|
12643
|
+
*
|
|
12644
|
+
* ### Required permissions
|
|
12645
|
+
* > [
|
|
12646
|
+
* {
|
|
12647
|
+
* "actions": [
|
|
12648
|
+
* "datasets:read"
|
|
12649
|
+
* ],
|
|
12650
|
+
* "datasets": [
|
|
12651
|
+
* {
|
|
12652
|
+
* "params": "dataset_id"
|
|
12653
|
+
* }
|
|
12654
|
+
* ]
|
|
12655
|
+
* }
|
|
12656
|
+
* ]
|
|
9514
12657
|
*/
|
|
9515
12658
|
ListDocuments: {
|
|
9516
12659
|
parameters: {
|
|
@@ -9781,7 +12924,23 @@ export interface operations {
|
|
|
9781
12924
|
};
|
|
9782
12925
|
};
|
|
9783
12926
|
};
|
|
9784
|
-
/**
|
|
12927
|
+
/**
|
|
12928
|
+
* Delete documents that match on a filters. At least one filter must be provided.
|
|
12929
|
+
*
|
|
12930
|
+
* ### Required permissions
|
|
12931
|
+
* > [
|
|
12932
|
+
* {
|
|
12933
|
+
* "actions": [
|
|
12934
|
+
* "datasets:write"
|
|
12935
|
+
* ],
|
|
12936
|
+
* "datasets": [
|
|
12937
|
+
* {
|
|
12938
|
+
* "params": "dataset_id"
|
|
12939
|
+
* }
|
|
12940
|
+
* ]
|
|
12941
|
+
* }
|
|
12942
|
+
* ]
|
|
12943
|
+
*/
|
|
9785
12944
|
DeleteWhere: {
|
|
9786
12945
|
parameters: {
|
|
9787
12946
|
path: {
|
|
@@ -9803,7 +12962,23 @@ export interface operations {
|
|
|
9803
12962
|
};
|
|
9804
12963
|
};
|
|
9805
12964
|
};
|
|
9806
|
-
/**
|
|
12965
|
+
/**
|
|
12966
|
+
* SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
|
|
12967
|
+
*
|
|
12968
|
+
* ### Required permissions
|
|
12969
|
+
* > [
|
|
12970
|
+
* {
|
|
12971
|
+
* "actions": [
|
|
12972
|
+
* "datasets:read"
|
|
12973
|
+
* ],
|
|
12974
|
+
* "datasets": [
|
|
12975
|
+
* {
|
|
12976
|
+
* "params": "dataset_id"
|
|
12977
|
+
* }
|
|
12978
|
+
* ]
|
|
12979
|
+
* }
|
|
12980
|
+
* ]
|
|
12981
|
+
*/
|
|
9807
12982
|
SimpleSearchPost: {
|
|
9808
12983
|
parameters: {
|
|
9809
12984
|
path: {
|
|
@@ -9825,7 +13000,23 @@ export interface operations {
|
|
|
9825
13000
|
};
|
|
9826
13001
|
};
|
|
9827
13002
|
};
|
|
9828
|
-
/**
|
|
13003
|
+
/**
|
|
13004
|
+
* SimpleSearch is an easy way to use vector search and traditional text matching to search your dataset. It also supports filtering, sorting and aggregating results.
|
|
13005
|
+
*
|
|
13006
|
+
* ### Required permissions
|
|
13007
|
+
* > [
|
|
13008
|
+
* {
|
|
13009
|
+
* "actions": [
|
|
13010
|
+
* "datasets:read"
|
|
13011
|
+
* ],
|
|
13012
|
+
* "datasets": [
|
|
13013
|
+
* {
|
|
13014
|
+
* "params": "dataset_id"
|
|
13015
|
+
* }
|
|
13016
|
+
* ]
|
|
13017
|
+
* }
|
|
13018
|
+
* ]
|
|
13019
|
+
*/
|
|
9829
13020
|
Search: {
|
|
9830
13021
|
parameters: {
|
|
9831
13022
|
path: {
|
|
@@ -9847,7 +13038,23 @@ export interface operations {
|
|
|
9847
13038
|
};
|
|
9848
13039
|
};
|
|
9849
13040
|
};
|
|
9850
|
-
/**
|
|
13041
|
+
/**
|
|
13042
|
+
* Recommend documents similar to specific documents. Specify which vector field must be used for recommendation using the documentsToRecommend property.
|
|
13043
|
+
*
|
|
13044
|
+
* ### Required permissions
|
|
13045
|
+
* > [
|
|
13046
|
+
* {
|
|
13047
|
+
* "actions": [
|
|
13048
|
+
* "datasets:read"
|
|
13049
|
+
* ],
|
|
13050
|
+
* "datasets": [
|
|
13051
|
+
* {
|
|
13052
|
+
* "params": "dataset_id"
|
|
13053
|
+
* }
|
|
13054
|
+
* ]
|
|
13055
|
+
* }
|
|
13056
|
+
* ]
|
|
13057
|
+
*/
|
|
9851
13058
|
Recommend: {
|
|
9852
13059
|
parameters: {
|
|
9853
13060
|
path: {
|
|
@@ -9869,6 +13076,31 @@ export interface operations {
|
|
|
9869
13076
|
};
|
|
9870
13077
|
};
|
|
9871
13078
|
};
|
|
13079
|
+
/**
|
|
13080
|
+
* ### Required permissions
|
|
13081
|
+
* > [
|
|
13082
|
+
* {
|
|
13083
|
+
* "actions": [
|
|
13084
|
+
* "datasets:read"
|
|
13085
|
+
* ],
|
|
13086
|
+
* "datasets": [
|
|
13087
|
+
* {
|
|
13088
|
+
* "params": "dataset_id"
|
|
13089
|
+
* }
|
|
13090
|
+
* ]
|
|
13091
|
+
* },
|
|
13092
|
+
* {
|
|
13093
|
+
* "actions": [
|
|
13094
|
+
* "datasets:write"
|
|
13095
|
+
* ],
|
|
13096
|
+
* "datasets": [
|
|
13097
|
+
* {
|
|
13098
|
+
* "body": "new_dataset_id"
|
|
13099
|
+
* }
|
|
13100
|
+
* ]
|
|
13101
|
+
* }
|
|
13102
|
+
* ]
|
|
13103
|
+
*/
|
|
9872
13104
|
CloneDataset: {
|
|
9873
13105
|
parameters: {
|
|
9874
13106
|
path: {
|
|
@@ -9890,7 +13122,23 @@ export interface operations {
|
|
|
9890
13122
|
};
|
|
9891
13123
|
};
|
|
9892
13124
|
};
|
|
9893
|
-
/**
|
|
13125
|
+
/**
|
|
13126
|
+
* Predict using KNN regression.
|
|
13127
|
+
*
|
|
13128
|
+
* ### Required permissions
|
|
13129
|
+
* > [
|
|
13130
|
+
* {
|
|
13131
|
+
* "actions": [
|
|
13132
|
+
* "datasets:read"
|
|
13133
|
+
* ],
|
|
13134
|
+
* "datasets": [
|
|
13135
|
+
* {
|
|
13136
|
+
* "body": "dataset_id"
|
|
13137
|
+
* }
|
|
13138
|
+
* ]
|
|
13139
|
+
* }
|
|
13140
|
+
* ]
|
|
13141
|
+
*/
|
|
9894
13142
|
PredictKNNRegression: {
|
|
9895
13143
|
parameters: {};
|
|
9896
13144
|
responses: {
|
|
@@ -9907,7 +13155,12 @@ export interface operations {
|
|
|
9907
13155
|
};
|
|
9908
13156
|
};
|
|
9909
13157
|
};
|
|
9910
|
-
/**
|
|
13158
|
+
/**
|
|
13159
|
+
* Predict using KNN regression from search results.
|
|
13160
|
+
*
|
|
13161
|
+
* ### Required permissions
|
|
13162
|
+
* > []
|
|
13163
|
+
*/
|
|
9911
13164
|
PredictKNNFromResults: {
|
|
9912
13165
|
parameters: {};
|
|
9913
13166
|
responses: {
|
|
@@ -9924,6 +13177,10 @@ export interface operations {
|
|
|
9924
13177
|
};
|
|
9925
13178
|
};
|
|
9926
13179
|
};
|
|
13180
|
+
/**
|
|
13181
|
+
* ### Required permissions
|
|
13182
|
+
* > []
|
|
13183
|
+
*/
|
|
9927
13184
|
BiasEvaluation: {
|
|
9928
13185
|
parameters: {};
|
|
9929
13186
|
responses: {
|
|
@@ -9940,6 +13197,10 @@ export interface operations {
|
|
|
9940
13197
|
};
|
|
9941
13198
|
};
|
|
9942
13199
|
};
|
|
13200
|
+
/**
|
|
13201
|
+
* ### Required permissions
|
|
13202
|
+
* > []
|
|
13203
|
+
*/
|
|
9943
13204
|
Vectorize: {
|
|
9944
13205
|
parameters: {};
|
|
9945
13206
|
responses: {
|
|
@@ -9956,6 +13217,21 @@ export interface operations {
|
|
|
9956
13217
|
};
|
|
9957
13218
|
};
|
|
9958
13219
|
};
|
|
13220
|
+
/**
|
|
13221
|
+
* ### Required permissions
|
|
13222
|
+
* > [
|
|
13223
|
+
* {
|
|
13224
|
+
* "actions": [
|
|
13225
|
+
* "datasets:write"
|
|
13226
|
+
* ],
|
|
13227
|
+
* "datasets": [
|
|
13228
|
+
* {
|
|
13229
|
+
* "params": "dataset_id"
|
|
13230
|
+
* }
|
|
13231
|
+
* ]
|
|
13232
|
+
* }
|
|
13233
|
+
* ]
|
|
13234
|
+
*/
|
|
9959
13235
|
VectorizeAndInsert: {
|
|
9960
13236
|
parameters: {
|
|
9961
13237
|
path: {
|
|
@@ -9977,6 +13253,21 @@ export interface operations {
|
|
|
9977
13253
|
};
|
|
9978
13254
|
};
|
|
9979
13255
|
};
|
|
13256
|
+
/**
|
|
13257
|
+
* ### Required permissions
|
|
13258
|
+
* > [
|
|
13259
|
+
* {
|
|
13260
|
+
* "actions": [
|
|
13261
|
+
* "datasets:write"
|
|
13262
|
+
* ],
|
|
13263
|
+
* "datasets": [
|
|
13264
|
+
* {
|
|
13265
|
+
* "params": "dataset_id"
|
|
13266
|
+
* }
|
|
13267
|
+
* ]
|
|
13268
|
+
* }
|
|
13269
|
+
* ]
|
|
13270
|
+
*/
|
|
9980
13271
|
VectorizeField: {
|
|
9981
13272
|
parameters: {
|
|
9982
13273
|
path: {
|
|
@@ -9998,6 +13289,22 @@ export interface operations {
|
|
|
9998
13289
|
};
|
|
9999
13290
|
};
|
|
10000
13291
|
};
|
|
13292
|
+
/**
|
|
13293
|
+
* ### Required permissions
|
|
13294
|
+
* > [
|
|
13295
|
+
* {
|
|
13296
|
+
* "actions": [
|
|
13297
|
+
* "datasets:read",
|
|
13298
|
+
* "datasets:write"
|
|
13299
|
+
* ],
|
|
13300
|
+
* "datasets": [
|
|
13301
|
+
* {
|
|
13302
|
+
* "body": "dataset_id"
|
|
13303
|
+
* }
|
|
13304
|
+
* ]
|
|
13305
|
+
* }
|
|
13306
|
+
* ]
|
|
13307
|
+
*/
|
|
10001
13308
|
TriggerWorkflow: {
|
|
10002
13309
|
parameters: {};
|
|
10003
13310
|
responses: {
|
|
@@ -10014,6 +13321,16 @@ export interface operations {
|
|
|
10014
13321
|
};
|
|
10015
13322
|
};
|
|
10016
13323
|
};
|
|
13324
|
+
/**
|
|
13325
|
+
* ### Required permissions
|
|
13326
|
+
* > [
|
|
13327
|
+
* {
|
|
13328
|
+
* "actions": [
|
|
13329
|
+
* "datasets:read"
|
|
13330
|
+
* ]
|
|
13331
|
+
* }
|
|
13332
|
+
* ]
|
|
13333
|
+
*/
|
|
10017
13334
|
ListWorkflows: {
|
|
10018
13335
|
parameters: {
|
|
10019
13336
|
query: {
|
|
@@ -10044,6 +13361,16 @@ export interface operations {
|
|
|
10044
13361
|
};
|
|
10045
13362
|
};
|
|
10046
13363
|
};
|
|
13364
|
+
/**
|
|
13365
|
+
* ### Required permissions
|
|
13366
|
+
* > [
|
|
13367
|
+
* {
|
|
13368
|
+
* "actions": [
|
|
13369
|
+
* "datasets:read"
|
|
13370
|
+
* ]
|
|
13371
|
+
* }
|
|
13372
|
+
* ]
|
|
13373
|
+
*/
|
|
10047
13374
|
GetWorkflowStatus: {
|
|
10048
13375
|
parameters: {
|
|
10049
13376
|
path: {
|
|
@@ -10065,6 +13392,16 @@ export interface operations {
|
|
|
10065
13392
|
};
|
|
10066
13393
|
};
|
|
10067
13394
|
};
|
|
13395
|
+
/**
|
|
13396
|
+
* ### Required permissions
|
|
13397
|
+
* > [
|
|
13398
|
+
* {
|
|
13399
|
+
* "actions": [
|
|
13400
|
+
* "datasets:write"
|
|
13401
|
+
* ]
|
|
13402
|
+
* }
|
|
13403
|
+
* ]
|
|
13404
|
+
*/
|
|
10068
13405
|
DeleteWorkflowStatus: {
|
|
10069
13406
|
parameters: {
|
|
10070
13407
|
path: {
|
|
@@ -10086,7 +13423,18 @@ export interface operations {
|
|
|
10086
13423
|
};
|
|
10087
13424
|
};
|
|
10088
13425
|
};
|
|
10089
|
-
/**
|
|
13426
|
+
/**
|
|
13427
|
+
* Update metadata for a workflow run
|
|
13428
|
+
*
|
|
13429
|
+
* ### Required permissions
|
|
13430
|
+
* > [
|
|
13431
|
+
* {
|
|
13432
|
+
* "actions": [
|
|
13433
|
+
* "datasets:write"
|
|
13434
|
+
* ]
|
|
13435
|
+
* }
|
|
13436
|
+
* ]
|
|
13437
|
+
*/
|
|
10090
13438
|
UpsertWorkflowMetadata: {
|
|
10091
13439
|
parameters: {
|
|
10092
13440
|
path: {
|
|
@@ -10108,7 +13456,18 @@ export interface operations {
|
|
|
10108
13456
|
};
|
|
10109
13457
|
};
|
|
10110
13458
|
};
|
|
10111
|
-
/**
|
|
13459
|
+
/**
|
|
13460
|
+
* Update status for a workflow run
|
|
13461
|
+
*
|
|
13462
|
+
* ### Required permissions
|
|
13463
|
+
* > [
|
|
13464
|
+
* {
|
|
13465
|
+
* "actions": [
|
|
13466
|
+
* "datasets:write"
|
|
13467
|
+
* ]
|
|
13468
|
+
* }
|
|
13469
|
+
* ]
|
|
13470
|
+
*/
|
|
10112
13471
|
UpsertWorkflowStatus: {
|
|
10113
13472
|
parameters: {
|
|
10114
13473
|
path: {
|
|
@@ -10130,6 +13489,10 @@ export interface operations {
|
|
|
10130
13489
|
};
|
|
10131
13490
|
};
|
|
10132
13491
|
};
|
|
13492
|
+
/**
|
|
13493
|
+
* ### Required permissions
|
|
13494
|
+
* > []
|
|
13495
|
+
*/
|
|
10133
13496
|
DeleteFieldChildren: {
|
|
10134
13497
|
parameters: {
|
|
10135
13498
|
path: {
|
|
@@ -10153,6 +13516,10 @@ export interface operations {
|
|
|
10153
13516
|
};
|
|
10154
13517
|
};
|
|
10155
13518
|
};
|
|
13519
|
+
/**
|
|
13520
|
+
* ### Required permissions
|
|
13521
|
+
* > []
|
|
13522
|
+
*/
|
|
10156
13523
|
ListFieldChildrens: {
|
|
10157
13524
|
parameters: {
|
|
10158
13525
|
path: {
|
|
@@ -10174,6 +13541,10 @@ export interface operations {
|
|
|
10174
13541
|
};
|
|
10175
13542
|
};
|
|
10176
13543
|
};
|
|
13544
|
+
/**
|
|
13545
|
+
* ### Required permissions
|
|
13546
|
+
* > []
|
|
13547
|
+
*/
|
|
10177
13548
|
UpdateFieldChildren: {
|
|
10178
13549
|
parameters: {
|
|
10179
13550
|
path: {
|
|
@@ -10197,6 +13568,10 @@ export interface operations {
|
|
|
10197
13568
|
};
|
|
10198
13569
|
};
|
|
10199
13570
|
};
|
|
13571
|
+
/**
|
|
13572
|
+
* ### Required permissions
|
|
13573
|
+
* > []
|
|
13574
|
+
*/
|
|
10200
13575
|
DeleteFavouriteWorkflow: {
|
|
10201
13576
|
parameters: {
|
|
10202
13577
|
path: {
|
|
@@ -10218,6 +13593,10 @@ export interface operations {
|
|
|
10218
13593
|
};
|
|
10219
13594
|
};
|
|
10220
13595
|
};
|
|
13596
|
+
/**
|
|
13597
|
+
* ### Required permissions
|
|
13598
|
+
* > []
|
|
13599
|
+
*/
|
|
10221
13600
|
ListFavouriteWorkflows: {
|
|
10222
13601
|
parameters: {};
|
|
10223
13602
|
responses: {
|
|
@@ -10234,6 +13613,10 @@ export interface operations {
|
|
|
10234
13613
|
};
|
|
10235
13614
|
};
|
|
10236
13615
|
};
|
|
13616
|
+
/**
|
|
13617
|
+
* ### Required permissions
|
|
13618
|
+
* > []
|
|
13619
|
+
*/
|
|
10237
13620
|
UpdateFavouriteWorkflow: {
|
|
10238
13621
|
parameters: {
|
|
10239
13622
|
path: {
|
|
@@ -10255,6 +13638,116 @@ export interface operations {
|
|
|
10255
13638
|
};
|
|
10256
13639
|
};
|
|
10257
13640
|
};
|
|
13641
|
+
/**
|
|
13642
|
+
* ### Required permissions
|
|
13643
|
+
* > []
|
|
13644
|
+
*/
|
|
13645
|
+
DeleteSavedFilter: {
|
|
13646
|
+
parameters: {
|
|
13647
|
+
path: {
|
|
13648
|
+
/** ID of savedfilter */
|
|
13649
|
+
savedfilter_id: string;
|
|
13650
|
+
};
|
|
13651
|
+
};
|
|
13652
|
+
responses: {
|
|
13653
|
+
/** successful operation */
|
|
13654
|
+
200: {
|
|
13655
|
+
content: {
|
|
13656
|
+
"application/json": components["schemas"]["DeleteSavedFilterOutput"];
|
|
13657
|
+
};
|
|
13658
|
+
};
|
|
13659
|
+
};
|
|
13660
|
+
requestBody: {
|
|
13661
|
+
content: {
|
|
13662
|
+
"application/json": components["schemas"]["DeleteSavedFilterInput"];
|
|
13663
|
+
};
|
|
13664
|
+
};
|
|
13665
|
+
};
|
|
13666
|
+
/**
|
|
13667
|
+
* ### Required permissions
|
|
13668
|
+
* > []
|
|
13669
|
+
*/
|
|
13670
|
+
ListSavedFilters: {
|
|
13671
|
+
parameters: {};
|
|
13672
|
+
responses: {
|
|
13673
|
+
/** successful operation */
|
|
13674
|
+
200: {
|
|
13675
|
+
content: {
|
|
13676
|
+
"application/json": components["schemas"]["ListSavedFiltersOutput"];
|
|
13677
|
+
};
|
|
13678
|
+
};
|
|
13679
|
+
};
|
|
13680
|
+
requestBody: {
|
|
13681
|
+
content: {
|
|
13682
|
+
"application/json": components["schemas"]["ListSavedFiltersInput"];
|
|
13683
|
+
};
|
|
13684
|
+
};
|
|
13685
|
+
};
|
|
13686
|
+
/**
|
|
13687
|
+
* ### Required permissions
|
|
13688
|
+
* > []
|
|
13689
|
+
*/
|
|
13690
|
+
UpdateSavedFilter: {
|
|
13691
|
+
parameters: {
|
|
13692
|
+
path: {
|
|
13693
|
+
/** ID of savedfilter */
|
|
13694
|
+
savedfilter_id: string;
|
|
13695
|
+
};
|
|
13696
|
+
};
|
|
13697
|
+
responses: {
|
|
13698
|
+
/** successful operation */
|
|
13699
|
+
200: {
|
|
13700
|
+
content: {
|
|
13701
|
+
"application/json": components["schemas"]["UpdateSavedFilterOutput"];
|
|
13702
|
+
};
|
|
13703
|
+
};
|
|
13704
|
+
};
|
|
13705
|
+
requestBody: {
|
|
13706
|
+
content: {
|
|
13707
|
+
"application/json": components["schemas"]["UpdateSavedFilterInput"];
|
|
13708
|
+
};
|
|
13709
|
+
};
|
|
13710
|
+
};
|
|
13711
|
+
/**
|
|
13712
|
+
* ### Required permissions
|
|
13713
|
+
* > []
|
|
13714
|
+
*/
|
|
13715
|
+
GetSavedFilter: {
|
|
13716
|
+
parameters: {
|
|
13717
|
+
path: {
|
|
13718
|
+
/** ID of savedfilter */
|
|
13719
|
+
savedfilter_id: string;
|
|
13720
|
+
};
|
|
13721
|
+
};
|
|
13722
|
+
responses: {
|
|
13723
|
+
/** successful operation */
|
|
13724
|
+
200: {
|
|
13725
|
+
content: {
|
|
13726
|
+
"application/json": components["schemas"]["GetSavedFilterOutput"];
|
|
13727
|
+
};
|
|
13728
|
+
};
|
|
13729
|
+
};
|
|
13730
|
+
};
|
|
13731
|
+
/**
|
|
13732
|
+
* ### Required permissions
|
|
13733
|
+
* > []
|
|
13734
|
+
*/
|
|
13735
|
+
CreateSavedFilter: {
|
|
13736
|
+
parameters: {};
|
|
13737
|
+
responses: {
|
|
13738
|
+
/** successful operation */
|
|
13739
|
+
200: {
|
|
13740
|
+
content: {
|
|
13741
|
+
"application/json": components["schemas"]["CreateSavedFilterOutput"];
|
|
13742
|
+
};
|
|
13743
|
+
};
|
|
13744
|
+
};
|
|
13745
|
+
requestBody: {
|
|
13746
|
+
content: {
|
|
13747
|
+
"application/json": components["schemas"]["CreateSavedFilterInput"];
|
|
13748
|
+
};
|
|
13749
|
+
};
|
|
13750
|
+
};
|
|
10258
13751
|
}
|
|
10259
13752
|
export interface external {
|
|
10260
13753
|
}
|