@worqio/sdk 0.0.0-stage → 0.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +202 -0
- package/README.md +47 -2
- package/dist/error.d.ts +14 -0
- package/dist/error.js +16 -0
- package/dist/gen/methods.gen.d.ts +309 -0
- package/dist/gen/methods.gen.js +259 -0
- package/dist/gen/types.gen.d.ts +3131 -0
- package/dist/gen/types.gen.js +2 -0
- package/dist/index.d.ts +27 -0
- package/dist/index.js +41 -0
- package/dist/request.d.ts +18 -0
- package/dist/request.js +139 -0
- package/openapi.json +12274 -0
- package/package.json +43 -5
|
@@ -0,0 +1,3131 @@
|
|
|
1
|
+
export type ClientOptions = {
|
|
2
|
+
baseUrl: "https://api.worqio.ai" | "https://api.staging.worqio.ai" | "http://localhost:3000/api" | (string & {});
|
|
3
|
+
};
|
|
4
|
+
export type ErrorEnvelopeSchema0 = string | number | boolean | null | Array<ErrorEnvelopeSchema0> | {
|
|
5
|
+
[key: string]: ErrorEnvelopeSchema0;
|
|
6
|
+
};
|
|
7
|
+
export type ErrorEnvelope = {
|
|
8
|
+
error: {
|
|
9
|
+
code: string;
|
|
10
|
+
message: string;
|
|
11
|
+
requestId: string;
|
|
12
|
+
details?: ErrorEnvelopeSchema0;
|
|
13
|
+
issues?: Array<{
|
|
14
|
+
path: string;
|
|
15
|
+
message: string;
|
|
16
|
+
}>;
|
|
17
|
+
};
|
|
18
|
+
};
|
|
19
|
+
export type EventsErasePersonResult = {
|
|
20
|
+
erasureId: string;
|
|
21
|
+
cutoffAt: string;
|
|
22
|
+
status: "pending" | "done";
|
|
23
|
+
};
|
|
24
|
+
export type EventsGetCatalogEntryResultSchema0 = string | null;
|
|
25
|
+
export type EventsGetCatalogEntryResultSchema1 = number;
|
|
26
|
+
export type EventsGetCatalogEntryResultSchema2 = string;
|
|
27
|
+
export type EventsGetCatalogEntryResultSchema3 = {
|
|
28
|
+
day: string;
|
|
29
|
+
accepted: EventsGetCatalogEntryResultSchema1;
|
|
30
|
+
withViolations: EventsGetCatalogEntryResultSchema1;
|
|
31
|
+
};
|
|
32
|
+
export type EventsGetCatalogEntryResultSchema4 = {
|
|
33
|
+
[key: string]: EventsGetCatalogEntryResultSchema5;
|
|
34
|
+
};
|
|
35
|
+
export type EventsGetCatalogEntryResultSchema5 = string | number | boolean | null | Array<EventsGetCatalogEntryResultSchema5> | {
|
|
36
|
+
[key: string]: EventsGetCatalogEntryResultSchema5;
|
|
37
|
+
};
|
|
38
|
+
export type EventsGetCatalogEntryResult = {
|
|
39
|
+
type: string;
|
|
40
|
+
name: string;
|
|
41
|
+
lane: "domain" | "behavior";
|
|
42
|
+
status: "visible" | "hidden" | "blocked";
|
|
43
|
+
description: EventsGetCatalogEntryResultSchema0;
|
|
44
|
+
typed: boolean;
|
|
45
|
+
standard: boolean;
|
|
46
|
+
available: boolean;
|
|
47
|
+
module?: string;
|
|
48
|
+
version?: EventsGetCatalogEntryResultSchema1;
|
|
49
|
+
similar?: boolean;
|
|
50
|
+
firstSeenAt?: EventsGetCatalogEntryResultSchema2 | null;
|
|
51
|
+
lastSeenAt: EventsGetCatalogEntryResultSchema2 | null;
|
|
52
|
+
last7d: EventsGetCatalogEntryResultSchema1 | null;
|
|
53
|
+
violations7d: EventsGetCatalogEntryResultSchema1 | null;
|
|
54
|
+
days: Array<EventsGetCatalogEntryResultSchema3> | null;
|
|
55
|
+
suggestion?: string;
|
|
56
|
+
entryKey?: string;
|
|
57
|
+
schema: EventsGetCatalogEntryResultSchema4 | boolean | null;
|
|
58
|
+
schemaVersion: EventsGetCatalogEntryResultSchema1;
|
|
59
|
+
observedProperties: EventsGetCatalogEntryResultSchema4;
|
|
60
|
+
truncated?: boolean;
|
|
61
|
+
timeline: boolean;
|
|
62
|
+
standardVersion?: EventsGetCatalogEntryResultSchema1 | null;
|
|
63
|
+
adoptedAt: EventsGetCatalogEntryResultSchema2 | null;
|
|
64
|
+
adoptedBy: EventsGetCatalogEntryResultSchema0;
|
|
65
|
+
activity: {
|
|
66
|
+
days: Array<EventsGetCatalogEntryResultSchema3>;
|
|
67
|
+
observed: Array<{
|
|
68
|
+
path: string;
|
|
69
|
+
types: Array<"array" | "boolean" | "integer" | "null" | "number" | "object" | "string">;
|
|
70
|
+
presence: number;
|
|
71
|
+
}>;
|
|
72
|
+
} | null;
|
|
73
|
+
history: Array<{
|
|
74
|
+
version: EventsGetCatalogEntryResultSchema1;
|
|
75
|
+
createdAt: EventsGetCatalogEntryResultSchema2;
|
|
76
|
+
createdBy: EventsGetCatalogEntryResultSchema0;
|
|
77
|
+
changes: Array<{
|
|
78
|
+
path: string;
|
|
79
|
+
kind: "added" | "removed" | "changed";
|
|
80
|
+
from: Array<string> | null;
|
|
81
|
+
to: Array<string> | null;
|
|
82
|
+
}>;
|
|
83
|
+
}>;
|
|
84
|
+
usage?: {
|
|
85
|
+
triggers: EventsGetCatalogEntryResultSchema1;
|
|
86
|
+
};
|
|
87
|
+
};
|
|
88
|
+
export type EventsGetErasureResultSchema0 = string;
|
|
89
|
+
export type EventsGetErasureResultSchema1 = number;
|
|
90
|
+
export type EventsGetErasureResult = {
|
|
91
|
+
id: string;
|
|
92
|
+
requestedAt: EventsGetErasureResultSchema0;
|
|
93
|
+
requestedBy: string | null;
|
|
94
|
+
cutoffAt: EventsGetErasureResultSchema0;
|
|
95
|
+
status: "pending" | "done";
|
|
96
|
+
pass1DoneAt: EventsGetErasureResultSchema0 | null;
|
|
97
|
+
pass2DoneAt: EventsGetErasureResultSchema0 | null;
|
|
98
|
+
pass2DueAt: EventsGetErasureResultSchema0;
|
|
99
|
+
archiveDoneAt: EventsGetErasureResultSchema0 | null;
|
|
100
|
+
matched: boolean;
|
|
101
|
+
found: {
|
|
102
|
+
events: EventsGetErasureResultSchema1;
|
|
103
|
+
identities: EventsGetErasureResultSchema1;
|
|
104
|
+
deliveries: EventsGetErasureResultSchema1;
|
|
105
|
+
} | null;
|
|
106
|
+
exportsDeleted: EventsGetErasureResultSchema1;
|
|
107
|
+
waitingDuty: Array<string>;
|
|
108
|
+
waitingModules: Array<string>;
|
|
109
|
+
};
|
|
110
|
+
export type EventsGetEventResultSchema0 = string | null;
|
|
111
|
+
export type EventsGetEventResultSchema1 = number;
|
|
112
|
+
export type EventsGetEventResultSchema2 = string;
|
|
113
|
+
export type EventsGetEventResultSchema3 = string | number | boolean | null | Array<EventsGetEventResultSchema3> | {
|
|
114
|
+
[key: string]: EventsGetEventResultSchema3;
|
|
115
|
+
};
|
|
116
|
+
export type EventsGetEventResultSchema4 = {
|
|
117
|
+
id: string;
|
|
118
|
+
eventId: string;
|
|
119
|
+
consumer: string;
|
|
120
|
+
consumerInfo: EventsGetEventResultSchema5;
|
|
121
|
+
module: string;
|
|
122
|
+
status: "pending" | "processing" | "delivered" | "failed" | "skipped" | "expired" | "replayed";
|
|
123
|
+
attempts: EventsGetEventResultSchema1;
|
|
124
|
+
dispatchAfter: EventsGetEventResultSchema2;
|
|
125
|
+
recordedAt: EventsGetEventResultSchema2;
|
|
126
|
+
settledAt: EventsGetEventResultSchema2 | null;
|
|
127
|
+
outcome: EventsGetEventResultSchema0;
|
|
128
|
+
replayOf: string | null;
|
|
129
|
+
replaySeq: EventsGetEventResultSchema1;
|
|
130
|
+
effects: Array<{
|
|
131
|
+
id: string;
|
|
132
|
+
kind: "idempotent" | "external";
|
|
133
|
+
label: string;
|
|
134
|
+
publishes?: string;
|
|
135
|
+
}>;
|
|
136
|
+
tries: Array<{
|
|
137
|
+
n: EventsGetEventResultSchema1;
|
|
138
|
+
startedAt: EventsGetEventResultSchema2;
|
|
139
|
+
durationMs: EventsGetEventResultSchema1 | null;
|
|
140
|
+
errorCode: EventsGetEventResultSchema0;
|
|
141
|
+
nextAttemptAt: EventsGetEventResultSchema2 | null;
|
|
142
|
+
sentEffects: Array<string>;
|
|
143
|
+
outcome: "running" | "delivered" | "failed" | "lost" | "skipped";
|
|
144
|
+
}>;
|
|
145
|
+
};
|
|
146
|
+
export type EventsGetEventResultSchema5 = {
|
|
147
|
+
key: string;
|
|
148
|
+
module: string;
|
|
149
|
+
label: string;
|
|
150
|
+
kind: "reactive" | "projection" | "duty" | "endpoint" | "destination";
|
|
151
|
+
};
|
|
152
|
+
export type EventsGetEventResult = {
|
|
153
|
+
event: {
|
|
154
|
+
id: string;
|
|
155
|
+
workspaceId: string;
|
|
156
|
+
lane: "domain" | "behavior" | "duty";
|
|
157
|
+
type: string;
|
|
158
|
+
name: EventsGetEventResultSchema0;
|
|
159
|
+
version: EventsGetEventResultSchema1;
|
|
160
|
+
occurredAt: EventsGetEventResultSchema2;
|
|
161
|
+
recordedAt: EventsGetEventResultSchema2;
|
|
162
|
+
origin: "user" | "agent" | "api" | "system" | "automation" | "seed" | "import" | "resync" | "sdk" | "integration";
|
|
163
|
+
actor: {
|
|
164
|
+
kind: "user" | "agent" | "operator" | "system";
|
|
165
|
+
id?: string;
|
|
166
|
+
module?: string;
|
|
167
|
+
} | null;
|
|
168
|
+
entity: {
|
|
169
|
+
type: string;
|
|
170
|
+
id: string;
|
|
171
|
+
version: EventsGetEventResultSchema1;
|
|
172
|
+
} | null;
|
|
173
|
+
correlationId: string;
|
|
174
|
+
causationId: string | null;
|
|
175
|
+
depth: EventsGetEventResultSchema1;
|
|
176
|
+
triggerEligible: boolean;
|
|
177
|
+
payload: EventsGetEventResultSchema3;
|
|
178
|
+
};
|
|
179
|
+
deliveries: Array<EventsGetEventResultSchema4>;
|
|
180
|
+
truncated: boolean;
|
|
181
|
+
masked: boolean;
|
|
182
|
+
chain: Array<{
|
|
183
|
+
id: string;
|
|
184
|
+
type: string;
|
|
185
|
+
depth: EventsGetEventResultSchema1;
|
|
186
|
+
recordedAt: EventsGetEventResultSchema2;
|
|
187
|
+
causationId: string | null;
|
|
188
|
+
deliveries: Array<EventsGetEventResultSchema4>;
|
|
189
|
+
gapConsumers: Array<EventsGetEventResultSchema5>;
|
|
190
|
+
}>;
|
|
191
|
+
};
|
|
192
|
+
export type EventsGetSourceResultSchema0 = string;
|
|
193
|
+
export type EventsGetSourceResult = {
|
|
194
|
+
source: {
|
|
195
|
+
id: string;
|
|
196
|
+
name: string;
|
|
197
|
+
kind: "server" | "browser" | "integration";
|
|
198
|
+
status: "active" | "archived";
|
|
199
|
+
allowedOrigins: Array<string>;
|
|
200
|
+
provider: string | null;
|
|
201
|
+
function?: string;
|
|
202
|
+
version: number;
|
|
203
|
+
createdAt: EventsGetSourceResultSchema0;
|
|
204
|
+
updatedAt: EventsGetSourceResultSchema0;
|
|
205
|
+
lastEventAt: EventsGetSourceResultSchema0 | null;
|
|
206
|
+
secretKeyBrowserSeenAt: EventsGetSourceResultSchema0 | null;
|
|
207
|
+
};
|
|
208
|
+
ingestBase: string;
|
|
209
|
+
};
|
|
210
|
+
export type EventsListCatalogResultSchema0 = "visible" | "hidden" | "blocked";
|
|
211
|
+
export type EventsListCatalogResultSchema1 = number;
|
|
212
|
+
export type EventsListCatalogResultSchema2 = string;
|
|
213
|
+
export type EventsListCatalogResult = {
|
|
214
|
+
data: Array<{
|
|
215
|
+
type: string;
|
|
216
|
+
name: string;
|
|
217
|
+
lane: "domain" | "behavior";
|
|
218
|
+
status: EventsListCatalogResultSchema0;
|
|
219
|
+
description: string | null;
|
|
220
|
+
typed: boolean;
|
|
221
|
+
standard: boolean;
|
|
222
|
+
available: boolean;
|
|
223
|
+
module?: string;
|
|
224
|
+
version?: EventsListCatalogResultSchema1;
|
|
225
|
+
similar?: boolean;
|
|
226
|
+
firstSeenAt?: EventsListCatalogResultSchema2 | null;
|
|
227
|
+
lastSeenAt: EventsListCatalogResultSchema2 | null;
|
|
228
|
+
last7d: EventsListCatalogResultSchema1 | null;
|
|
229
|
+
violations7d: EventsListCatalogResultSchema1 | null;
|
|
230
|
+
days: Array<{
|
|
231
|
+
day: string;
|
|
232
|
+
accepted: EventsListCatalogResultSchema1;
|
|
233
|
+
withViolations: EventsListCatalogResultSchema1;
|
|
234
|
+
}> | null;
|
|
235
|
+
suggestion?: string;
|
|
236
|
+
entryKey?: string;
|
|
237
|
+
}>;
|
|
238
|
+
nextCursor: string | null;
|
|
239
|
+
totals: {
|
|
240
|
+
total: EventsListCatalogResultSchema1;
|
|
241
|
+
visible: EventsListCatalogResultSchema1;
|
|
242
|
+
status: {
|
|
243
|
+
[key in EventsListCatalogResultSchema0]?: EventsListCatalogResultSchema1;
|
|
244
|
+
};
|
|
245
|
+
lane: {
|
|
246
|
+
behavior: EventsListCatalogResultSchema1;
|
|
247
|
+
domain: EventsListCatalogResultSchema1;
|
|
248
|
+
};
|
|
249
|
+
};
|
|
250
|
+
};
|
|
251
|
+
export type EventsListDeliveriesResultSchema0 = number;
|
|
252
|
+
export type EventsListDeliveriesResultSchema1 = string;
|
|
253
|
+
export type EventsListDeliveriesResultSchema2 = string | null;
|
|
254
|
+
export type EventsListDeliveriesResult = {
|
|
255
|
+
data: Array<{
|
|
256
|
+
id: string;
|
|
257
|
+
eventId: string;
|
|
258
|
+
consumer: string;
|
|
259
|
+
consumerInfo: {
|
|
260
|
+
key: string;
|
|
261
|
+
module: string;
|
|
262
|
+
label: string;
|
|
263
|
+
kind: "reactive" | "projection" | "duty" | "endpoint" | "destination";
|
|
264
|
+
};
|
|
265
|
+
module: string;
|
|
266
|
+
status: "pending" | "processing" | "delivered" | "failed" | "skipped" | "expired" | "replayed";
|
|
267
|
+
attempts: EventsListDeliveriesResultSchema0;
|
|
268
|
+
dispatchAfter: EventsListDeliveriesResultSchema1;
|
|
269
|
+
recordedAt: EventsListDeliveriesResultSchema1;
|
|
270
|
+
settledAt: EventsListDeliveriesResultSchema1 | null;
|
|
271
|
+
outcome: EventsListDeliveriesResultSchema2;
|
|
272
|
+
replayOf: string | null;
|
|
273
|
+
replaySeq: EventsListDeliveriesResultSchema0;
|
|
274
|
+
effects: Array<{
|
|
275
|
+
id: string;
|
|
276
|
+
kind: "idempotent" | "external";
|
|
277
|
+
label: string;
|
|
278
|
+
publishes?: string;
|
|
279
|
+
}>;
|
|
280
|
+
tries: Array<{
|
|
281
|
+
n: EventsListDeliveriesResultSchema0;
|
|
282
|
+
startedAt: EventsListDeliveriesResultSchema1;
|
|
283
|
+
durationMs: EventsListDeliveriesResultSchema0 | null;
|
|
284
|
+
errorCode: EventsListDeliveriesResultSchema2;
|
|
285
|
+
nextAttemptAt: EventsListDeliveriesResultSchema1 | null;
|
|
286
|
+
sentEffects: Array<string>;
|
|
287
|
+
outcome: "running" | "delivered" | "failed" | "lost" | "skipped";
|
|
288
|
+
}>;
|
|
289
|
+
eventType: EventsListDeliveriesResultSchema2;
|
|
290
|
+
eventName: EventsListDeliveriesResultSchema2;
|
|
291
|
+
}>;
|
|
292
|
+
nextCursor: string | null;
|
|
293
|
+
};
|
|
294
|
+
export type EventsListErasuresResultSchema0 = string;
|
|
295
|
+
export type EventsListErasuresResultSchema1 = number;
|
|
296
|
+
export type EventsListErasuresResult = {
|
|
297
|
+
data: Array<{
|
|
298
|
+
id: string;
|
|
299
|
+
requestedAt: EventsListErasuresResultSchema0;
|
|
300
|
+
requestedBy: string | null;
|
|
301
|
+
cutoffAt: EventsListErasuresResultSchema0;
|
|
302
|
+
status: "pending" | "done";
|
|
303
|
+
pass1DoneAt: EventsListErasuresResultSchema0 | null;
|
|
304
|
+
pass2DoneAt: EventsListErasuresResultSchema0 | null;
|
|
305
|
+
pass2DueAt: EventsListErasuresResultSchema0;
|
|
306
|
+
archiveDoneAt: EventsListErasuresResultSchema0 | null;
|
|
307
|
+
matched: boolean;
|
|
308
|
+
found: {
|
|
309
|
+
events: EventsListErasuresResultSchema1;
|
|
310
|
+
identities: EventsListErasuresResultSchema1;
|
|
311
|
+
deliveries: EventsListErasuresResultSchema1;
|
|
312
|
+
} | null;
|
|
313
|
+
exportsDeleted: EventsListErasuresResultSchema1;
|
|
314
|
+
waitingDuty: Array<string>;
|
|
315
|
+
waitingModules: Array<string>;
|
|
316
|
+
}>;
|
|
317
|
+
nextCursor: string | null;
|
|
318
|
+
};
|
|
319
|
+
export type EventsListGapsResultSchema0 = number;
|
|
320
|
+
export type EventsListGapsResultSchema1 = string;
|
|
321
|
+
export type EventsListGapsResult = {
|
|
322
|
+
data: Array<{
|
|
323
|
+
generation: string;
|
|
324
|
+
progress: {
|
|
325
|
+
done: EventsListGapsResultSchema0;
|
|
326
|
+
total: EventsListGapsResultSchema0;
|
|
327
|
+
} | null;
|
|
328
|
+
consumerInfo: {
|
|
329
|
+
key: string;
|
|
330
|
+
module: string;
|
|
331
|
+
label: string;
|
|
332
|
+
kind: "reactive" | "projection" | "duty" | "endpoint" | "destination";
|
|
333
|
+
};
|
|
334
|
+
module: string;
|
|
335
|
+
consumer: string;
|
|
336
|
+
from: EventsListGapsResultSchema1;
|
|
337
|
+
to: EventsListGapsResultSchema1;
|
|
338
|
+
skipped: EventsListGapsResultSchema0;
|
|
339
|
+
closedAt: EventsListGapsResultSchema1 | null;
|
|
340
|
+
backfillAt: EventsListGapsResultSchema1 | null;
|
|
341
|
+
backfill?: "done" | "failed" | "running" | "pending";
|
|
342
|
+
}>;
|
|
343
|
+
nextCursor: null;
|
|
344
|
+
};
|
|
345
|
+
export type EventsListSourcesResultSchema0 = number;
|
|
346
|
+
export type EventsListSourcesResultSchema1 = string;
|
|
347
|
+
export type EventsListSourcesResult = {
|
|
348
|
+
data: Array<{
|
|
349
|
+
id: string;
|
|
350
|
+
name: string;
|
|
351
|
+
kind: "server" | "browser" | "integration";
|
|
352
|
+
status: "active" | "archived";
|
|
353
|
+
allowedOrigins: Array<string>;
|
|
354
|
+
provider: string | null;
|
|
355
|
+
function?: string;
|
|
356
|
+
version: EventsListSourcesResultSchema0;
|
|
357
|
+
createdAt: EventsListSourcesResultSchema1;
|
|
358
|
+
updatedAt: EventsListSourcesResultSchema1;
|
|
359
|
+
lastEventAt: EventsListSourcesResultSchema1 | null;
|
|
360
|
+
secretKeyBrowserSeenAt: EventsListSourcesResultSchema1 | null;
|
|
361
|
+
events24h: EventsListSourcesResultSchema0 | null;
|
|
362
|
+
activityToday: {
|
|
363
|
+
day: string;
|
|
364
|
+
events: EventsListSourcesResultSchema0;
|
|
365
|
+
} | null;
|
|
366
|
+
activity24h: Array<{
|
|
367
|
+
hour: EventsListSourcesResultSchema1;
|
|
368
|
+
events: EventsListSourcesResultSchema0;
|
|
369
|
+
}> | null;
|
|
370
|
+
stats24h?: {
|
|
371
|
+
events: EventsListSourcesResultSchema0;
|
|
372
|
+
ignored: EventsListSourcesResultSchema0;
|
|
373
|
+
mappingFailures: EventsListSourcesResultSchema0;
|
|
374
|
+
};
|
|
375
|
+
}>;
|
|
376
|
+
nextCursor: null;
|
|
377
|
+
};
|
|
378
|
+
export type EventsSearchResultSchema0 = string | null;
|
|
379
|
+
export type EventsSearchResultSchema1 = {
|
|
380
|
+
[key: string]: EventsSearchResultSchema2;
|
|
381
|
+
};
|
|
382
|
+
export type EventsSearchResultSchema2 = string | number | boolean | null | Array<EventsSearchResultSchema2> | {
|
|
383
|
+
[key: string]: EventsSearchResultSchema2;
|
|
384
|
+
};
|
|
385
|
+
export type EventsSearchResultSchema3 = string;
|
|
386
|
+
export type EventsSearchResultSchema4 = string | number | boolean | null | Array<EventsSearchResultSchema4> | {
|
|
387
|
+
[key: string]: EventsSearchResultSchema4;
|
|
388
|
+
};
|
|
389
|
+
export type EventsSearchResult = {
|
|
390
|
+
events: Array<{
|
|
391
|
+
workspaceId: string;
|
|
392
|
+
ingestId: string;
|
|
393
|
+
sourceId: string;
|
|
394
|
+
messageId: string;
|
|
395
|
+
type: "track" | "identify" | "page" | "group";
|
|
396
|
+
event?: string;
|
|
397
|
+
anonymousId?: EventsSearchResultSchema0;
|
|
398
|
+
userId?: EventsSearchResultSchema0;
|
|
399
|
+
groupId?: EventsSearchResultSchema0;
|
|
400
|
+
properties?: EventsSearchResultSchema1;
|
|
401
|
+
traits?: EventsSearchResultSchema1;
|
|
402
|
+
context: EventsSearchResultSchema1;
|
|
403
|
+
originalTimestamp?: string;
|
|
404
|
+
sentAt?: string;
|
|
405
|
+
receivedAt: EventsSearchResultSchema3;
|
|
406
|
+
processedAt?: EventsSearchResultSchema3;
|
|
407
|
+
origin?: "integration";
|
|
408
|
+
timestamp: EventsSearchResultSchema3;
|
|
409
|
+
trust: "write" | "secret" | "integration" | "public" | "provider";
|
|
410
|
+
identityVerified: boolean;
|
|
411
|
+
flags: Array<string>;
|
|
412
|
+
masked?: true;
|
|
413
|
+
violations: Array<{
|
|
414
|
+
path: string;
|
|
415
|
+
message: string;
|
|
416
|
+
expected?: string;
|
|
417
|
+
value?: EventsSearchResultSchema4;
|
|
418
|
+
}>;
|
|
419
|
+
}>;
|
|
420
|
+
truncated: boolean;
|
|
421
|
+
masked: boolean;
|
|
422
|
+
};
|
|
423
|
+
export type EventsStatusResultSchema0 = number;
|
|
424
|
+
export type EventsStatusResult = {
|
|
425
|
+
ingest5m: {
|
|
426
|
+
accepted: EventsStatusResultSchema0;
|
|
427
|
+
rejected: EventsStatusResultSchema0;
|
|
428
|
+
};
|
|
429
|
+
quota: {
|
|
430
|
+
used: EventsStatusResultSchema0;
|
|
431
|
+
publicUsed: EventsStatusResultSchema0;
|
|
432
|
+
trustedUsed: EventsStatusResultSchema0;
|
|
433
|
+
limit: EventsStatusResultSchema0;
|
|
434
|
+
publicLimit: EventsStatusResultSchema0;
|
|
435
|
+
hours: Array<{
|
|
436
|
+
hour: string;
|
|
437
|
+
public: EventsStatusResultSchema0;
|
|
438
|
+
server: EventsStatusResultSchema0;
|
|
439
|
+
integrations: EventsStatusResultSchema0;
|
|
440
|
+
}> | null;
|
|
441
|
+
};
|
|
442
|
+
pending: EventsStatusResultSchema0;
|
|
443
|
+
processing: EventsStatusResultSchema0;
|
|
444
|
+
failed24h: EventsStatusResultSchema0;
|
|
445
|
+
oldestPendingSeconds: EventsStatusResultSchema0 | null;
|
|
446
|
+
openGaps: EventsStatusResultSchema0;
|
|
447
|
+
backfills: {
|
|
448
|
+
running: EventsStatusResultSchema0;
|
|
449
|
+
failed: EventsStatusResultSchema0;
|
|
450
|
+
};
|
|
451
|
+
partitionsAheadDays: number;
|
|
452
|
+
clickhouseLoadLagSeconds: number | null;
|
|
453
|
+
ingestBase: string;
|
|
454
|
+
trend: {
|
|
455
|
+
delivered: Array<EventsStatusResultSchema0>;
|
|
456
|
+
pending: Array<EventsStatusResultSchema0>;
|
|
457
|
+
failed: Array<EventsStatusResultSchema0>;
|
|
458
|
+
failedPrevious: EventsStatusResultSchema0;
|
|
459
|
+
};
|
|
460
|
+
};
|
|
461
|
+
export type ProductsAddOfferResult = {
|
|
462
|
+
id: string;
|
|
463
|
+
slug: string;
|
|
464
|
+
label: string;
|
|
465
|
+
excluded: boolean;
|
|
466
|
+
isDefault: boolean;
|
|
467
|
+
archived: boolean;
|
|
468
|
+
version: number;
|
|
469
|
+
aliases: Array<string>;
|
|
470
|
+
offerCount: number;
|
|
471
|
+
ruleCount: number;
|
|
472
|
+
updatedAt: string;
|
|
473
|
+
offers: Array<{
|
|
474
|
+
id: string;
|
|
475
|
+
source: string;
|
|
476
|
+
externalId: string;
|
|
477
|
+
label: string | null;
|
|
478
|
+
createdAt: string;
|
|
479
|
+
}>;
|
|
480
|
+
rules: Array<{
|
|
481
|
+
id: string;
|
|
482
|
+
productId: string;
|
|
483
|
+
pattern: string;
|
|
484
|
+
matchType: "contains" | "prefix" | "regex";
|
|
485
|
+
funnel: "awareness" | "traffic" | "conversion" | null;
|
|
486
|
+
priority: number;
|
|
487
|
+
enabled: boolean;
|
|
488
|
+
updatedAt: string;
|
|
489
|
+
}>;
|
|
490
|
+
};
|
|
491
|
+
export type ProductsListResult = {
|
|
492
|
+
data: Array<{
|
|
493
|
+
id: string;
|
|
494
|
+
slug: string;
|
|
495
|
+
label: string;
|
|
496
|
+
excluded: boolean;
|
|
497
|
+
isDefault: boolean;
|
|
498
|
+
archived: boolean;
|
|
499
|
+
version: number;
|
|
500
|
+
aliases: Array<string>;
|
|
501
|
+
offerCount: number;
|
|
502
|
+
ruleCount: number;
|
|
503
|
+
updatedAt: string;
|
|
504
|
+
}>;
|
|
505
|
+
nextCursor: null;
|
|
506
|
+
};
|
|
507
|
+
export type ProductsListAdRulesResult = {
|
|
508
|
+
data: Array<{
|
|
509
|
+
id: string;
|
|
510
|
+
productId: string;
|
|
511
|
+
pattern: string;
|
|
512
|
+
matchType: "contains" | "prefix" | "regex";
|
|
513
|
+
funnel: "awareness" | "traffic" | "conversion" | null;
|
|
514
|
+
priority: number;
|
|
515
|
+
enabled: boolean;
|
|
516
|
+
updatedAt: string;
|
|
517
|
+
}>;
|
|
518
|
+
nextCursor: null;
|
|
519
|
+
};
|
|
520
|
+
export type ProductsMatchAdResult = {
|
|
521
|
+
product: {
|
|
522
|
+
id: string;
|
|
523
|
+
slug: string;
|
|
524
|
+
label: string;
|
|
525
|
+
} | null;
|
|
526
|
+
funnel: "awareness" | "traffic" | "conversion" | null;
|
|
527
|
+
ruleId: string | null;
|
|
528
|
+
};
|
|
529
|
+
export type ProductsResolveResult = {
|
|
530
|
+
id: string;
|
|
531
|
+
slug: string;
|
|
532
|
+
label: string;
|
|
533
|
+
} | null;
|
|
534
|
+
export type TasksCommentAddResultSchema0 = string | null;
|
|
535
|
+
export type TasksCommentAddResultSchema1 = string;
|
|
536
|
+
export type TasksCommentAddResult = {
|
|
537
|
+
id: string;
|
|
538
|
+
task: string;
|
|
539
|
+
author: string;
|
|
540
|
+
authorLabel: string;
|
|
541
|
+
via: "user" | "agent";
|
|
542
|
+
client: TasksCommentAddResultSchema0;
|
|
543
|
+
clientName: TasksCommentAddResultSchema0;
|
|
544
|
+
body: string;
|
|
545
|
+
createdAt: TasksCommentAddResultSchema1;
|
|
546
|
+
editedAt: TasksCommentAddResultSchema1 | null;
|
|
547
|
+
deletedAt: TasksCommentAddResultSchema1 | null;
|
|
548
|
+
deleted: boolean;
|
|
549
|
+
};
|
|
550
|
+
export type TasksCommentListResultSchema0 = string | null;
|
|
551
|
+
export type TasksCommentListResultSchema1 = string;
|
|
552
|
+
export type TasksCommentListResult = {
|
|
553
|
+
data: Array<{
|
|
554
|
+
id: string;
|
|
555
|
+
task: string;
|
|
556
|
+
author: string;
|
|
557
|
+
authorLabel: string;
|
|
558
|
+
via: "user" | "agent";
|
|
559
|
+
client: TasksCommentListResultSchema0;
|
|
560
|
+
clientName: TasksCommentListResultSchema0;
|
|
561
|
+
body: string;
|
|
562
|
+
createdAt: TasksCommentListResultSchema1;
|
|
563
|
+
editedAt: TasksCommentListResultSchema1 | null;
|
|
564
|
+
deletedAt: TasksCommentListResultSchema1 | null;
|
|
565
|
+
deleted: boolean;
|
|
566
|
+
}>;
|
|
567
|
+
nextCursor: string | null;
|
|
568
|
+
};
|
|
569
|
+
export type TasksTaskArchiveResultSchema0 = string;
|
|
570
|
+
export type TasksTaskArchiveResultSchema1 = string;
|
|
571
|
+
export type TasksTaskArchiveResultSchema2 = string;
|
|
572
|
+
export type TasksTaskArchiveResultSchema3 = string;
|
|
573
|
+
export type TasksTaskArchiveResultSchema4 = {
|
|
574
|
+
id: string;
|
|
575
|
+
name: string;
|
|
576
|
+
category: "backlog" | "unstarted" | "started" | "completed" | "canceled";
|
|
577
|
+
};
|
|
578
|
+
export type TasksTaskArchiveResultSchema5 = 0 | 1 | 2 | 3 | 4;
|
|
579
|
+
export type TasksTaskArchiveResultSchema6 = string | null;
|
|
580
|
+
export type TasksTaskArchiveResultSchema7 = string | null;
|
|
581
|
+
export type TasksTaskArchiveResultSchema8 = boolean;
|
|
582
|
+
export type TasksTaskArchiveResultSchema9 = Array<{
|
|
583
|
+
id: string;
|
|
584
|
+
name: string;
|
|
585
|
+
color: TasksTaskArchiveResultSchema10;
|
|
586
|
+
group?: {
|
|
587
|
+
id: string;
|
|
588
|
+
name: string;
|
|
589
|
+
exclusive: boolean;
|
|
590
|
+
} | null;
|
|
591
|
+
}>;
|
|
592
|
+
export type TasksTaskArchiveResultSchema10 = "gray" | "red" | "orange" | "amber" | "green" | "teal" | "blue" | "indigo" | "purple" | "pink";
|
|
593
|
+
export type TasksTaskArchiveResultSchema11 = {
|
|
594
|
+
id: TasksTaskArchiveResultSchema0;
|
|
595
|
+
identifier: TasksTaskArchiveResultSchema1;
|
|
596
|
+
team: TasksTaskArchiveResultSchema2;
|
|
597
|
+
title: TasksTaskArchiveResultSchema3;
|
|
598
|
+
status: TasksTaskArchiveResultSchema4;
|
|
599
|
+
priority: TasksTaskArchiveResultSchema5;
|
|
600
|
+
assignee: TasksTaskArchiveResultSchema6;
|
|
601
|
+
dueDate: TasksTaskArchiveResultSchema7;
|
|
602
|
+
overdue: TasksTaskArchiveResultSchema8;
|
|
603
|
+
labels: TasksTaskArchiveResultSchema9;
|
|
604
|
+
parent: string | null;
|
|
605
|
+
subtasks: {
|
|
606
|
+
total: TasksTaskArchiveResultSchema12;
|
|
607
|
+
done: TasksTaskArchiveResultSchema12;
|
|
608
|
+
};
|
|
609
|
+
project?: TasksTaskArchiveResultSchema13;
|
|
610
|
+
milestone?: TasksTaskArchiveResultSchema14;
|
|
611
|
+
series?: TasksTaskArchiveResultSchema15;
|
|
612
|
+
blocked: TasksTaskArchiveResultSchema22;
|
|
613
|
+
blockedVia: TasksTaskArchiveResultSchema23;
|
|
614
|
+
blockedParent: TasksTaskArchiveResultSchema6;
|
|
615
|
+
archived: TasksTaskArchiveResultSchema24;
|
|
616
|
+
updatedAt: TasksTaskArchiveResultSchema25;
|
|
617
|
+
createdAt: TasksTaskArchiveResultSchema25;
|
|
618
|
+
};
|
|
619
|
+
export type TasksTaskArchiveResultSchema12 = number;
|
|
620
|
+
export type TasksTaskArchiveResultSchema13 = {
|
|
621
|
+
id: string;
|
|
622
|
+
name: string;
|
|
623
|
+
color: TasksTaskArchiveResultSchema10;
|
|
624
|
+
archived: boolean;
|
|
625
|
+
} | null;
|
|
626
|
+
export type TasksTaskArchiveResultSchema14 = {
|
|
627
|
+
id: string;
|
|
628
|
+
name: string;
|
|
629
|
+
position: number;
|
|
630
|
+
} | null;
|
|
631
|
+
export type TasksTaskArchiveResultSchema15 = {
|
|
632
|
+
id: string;
|
|
633
|
+
seq: TasksTaskArchiveResultSchema12;
|
|
634
|
+
live: boolean;
|
|
635
|
+
status: "active" | "paused" | "ended";
|
|
636
|
+
mode: "schedule" | "completion";
|
|
637
|
+
rule: {
|
|
638
|
+
freq: "daily";
|
|
639
|
+
interval: TasksTaskArchiveResultSchema16;
|
|
640
|
+
end: TasksTaskArchiveResultSchema17;
|
|
641
|
+
} | {
|
|
642
|
+
freq: "weekly";
|
|
643
|
+
interval: TasksTaskArchiveResultSchema16;
|
|
644
|
+
end: TasksTaskArchiveResultSchema17;
|
|
645
|
+
weekdays: Array<TasksTaskArchiveResultSchema18>;
|
|
646
|
+
} | {
|
|
647
|
+
freq: "monthly";
|
|
648
|
+
interval: TasksTaskArchiveResultSchema16;
|
|
649
|
+
end: TasksTaskArchiveResultSchema17;
|
|
650
|
+
monthDay: "last" | number;
|
|
651
|
+
} | {
|
|
652
|
+
freq: TasksTaskArchiveResultSchema19;
|
|
653
|
+
interval: TasksTaskArchiveResultSchema16;
|
|
654
|
+
end: TasksTaskArchiveResultSchema17;
|
|
655
|
+
month: TasksTaskArchiveResultSchema20;
|
|
656
|
+
day: TasksTaskArchiveResultSchema21;
|
|
657
|
+
};
|
|
658
|
+
anchorDate: string;
|
|
659
|
+
model: {
|
|
660
|
+
title: string;
|
|
661
|
+
descriptionMd: string;
|
|
662
|
+
assignee: TasksTaskArchiveResultSchema6;
|
|
663
|
+
priority: TasksTaskArchiveResultSchema5;
|
|
664
|
+
labelIds: Array<string>;
|
|
665
|
+
projectId: string | null;
|
|
666
|
+
subtasks: Array<{
|
|
667
|
+
title: string;
|
|
668
|
+
assignee: TasksTaskArchiveResultSchema6;
|
|
669
|
+
priority: TasksTaskArchiveResultSchema5;
|
|
670
|
+
}>;
|
|
671
|
+
};
|
|
672
|
+
} | null;
|
|
673
|
+
export type TasksTaskArchiveResultSchema16 = number;
|
|
674
|
+
export type TasksTaskArchiveResultSchema17 = {
|
|
675
|
+
kind: "never";
|
|
676
|
+
} | {
|
|
677
|
+
kind: "until";
|
|
678
|
+
date: string;
|
|
679
|
+
} | {
|
|
680
|
+
kind: "count";
|
|
681
|
+
count: number;
|
|
682
|
+
};
|
|
683
|
+
export type TasksTaskArchiveResultSchema18 = 1 | 2 | 3 | 4 | 5 | 6 | 7;
|
|
684
|
+
export type TasksTaskArchiveResultSchema19 = "yearly";
|
|
685
|
+
export type TasksTaskArchiveResultSchema20 = number;
|
|
686
|
+
export type TasksTaskArchiveResultSchema21 = number;
|
|
687
|
+
export type TasksTaskArchiveResultSchema22 = boolean;
|
|
688
|
+
export type TasksTaskArchiveResultSchema23 = "self" | "parent" | "both" | null;
|
|
689
|
+
export type TasksTaskArchiveResultSchema24 = boolean;
|
|
690
|
+
export type TasksTaskArchiveResultSchema25 = string;
|
|
691
|
+
export type TasksTaskArchiveResultSchema26 = string;
|
|
692
|
+
export type TasksTaskArchiveResultSchema27 = {
|
|
693
|
+
identifier: TasksTaskArchiveResultSchema26;
|
|
694
|
+
};
|
|
695
|
+
export type TasksTaskArchiveResult = {
|
|
696
|
+
id: TasksTaskArchiveResultSchema0;
|
|
697
|
+
identifier: TasksTaskArchiveResultSchema1;
|
|
698
|
+
team: TasksTaskArchiveResultSchema2;
|
|
699
|
+
title: TasksTaskArchiveResultSchema3;
|
|
700
|
+
status: TasksTaskArchiveResultSchema4;
|
|
701
|
+
priority: TasksTaskArchiveResultSchema5;
|
|
702
|
+
assignee: TasksTaskArchiveResultSchema6;
|
|
703
|
+
dueDate: TasksTaskArchiveResultSchema7;
|
|
704
|
+
overdue: TasksTaskArchiveResultSchema8;
|
|
705
|
+
labels: TasksTaskArchiveResultSchema9;
|
|
706
|
+
parent: TasksTaskArchiveResultSchema11 | null;
|
|
707
|
+
subtasks: Array<TasksTaskArchiveResultSchema11>;
|
|
708
|
+
project?: TasksTaskArchiveResultSchema13;
|
|
709
|
+
milestone?: TasksTaskArchiveResultSchema14;
|
|
710
|
+
series?: TasksTaskArchiveResultSchema15;
|
|
711
|
+
blocked: TasksTaskArchiveResultSchema22;
|
|
712
|
+
blockedVia: TasksTaskArchiveResultSchema23;
|
|
713
|
+
blockedParent: TasksTaskArchiveResultSchema6;
|
|
714
|
+
archived: TasksTaskArchiveResultSchema24;
|
|
715
|
+
updatedAt: TasksTaskArchiveResultSchema25;
|
|
716
|
+
createdAt: TasksTaskArchiveResultSchema25;
|
|
717
|
+
description: string;
|
|
718
|
+
descriptionVersion: TasksTaskArchiveResultSchema12;
|
|
719
|
+
previousIdentifiers: Array<string>;
|
|
720
|
+
relations: Array<{
|
|
721
|
+
id: string;
|
|
722
|
+
taskId: string;
|
|
723
|
+
relatedTaskId: string;
|
|
724
|
+
kind: "blocks" | "blocked_by" | "related" | "duplicate_of" | "duplicate";
|
|
725
|
+
other: TasksTaskArchiveResultSchema11;
|
|
726
|
+
}>;
|
|
727
|
+
followers: Array<string>;
|
|
728
|
+
createdBy: {
|
|
729
|
+
userId: TasksTaskArchiveResultSchema6;
|
|
730
|
+
via: "user" | "agent" | "system";
|
|
731
|
+
client: TasksTaskArchiveResultSchema6;
|
|
732
|
+
};
|
|
733
|
+
createdActorLabel: TasksTaskArchiveResultSchema6;
|
|
734
|
+
createdByAgentName: TasksTaskArchiveResultSchema6;
|
|
735
|
+
startedAt: TasksTaskArchiveResultSchema25 | null;
|
|
736
|
+
completedAt: TasksTaskArchiveResultSchema25 | null;
|
|
737
|
+
canceledAt: TasksTaskArchiveResultSchema25 | null;
|
|
738
|
+
url: string;
|
|
739
|
+
branchName: string;
|
|
740
|
+
born?: {
|
|
741
|
+
identifier: TasksTaskArchiveResultSchema26;
|
|
742
|
+
dueDate: string;
|
|
743
|
+
seq: TasksTaskArchiveResultSchema12;
|
|
744
|
+
};
|
|
745
|
+
unborn?: TasksTaskArchiveResultSchema27;
|
|
746
|
+
kept?: TasksTaskArchiveResultSchema27;
|
|
747
|
+
bornTasks?: Array<{
|
|
748
|
+
identifier: TasksTaskArchiveResultSchema26;
|
|
749
|
+
from: string;
|
|
750
|
+
dueDate: string;
|
|
751
|
+
}>;
|
|
752
|
+
externalLinks?: Array<{
|
|
753
|
+
id: string;
|
|
754
|
+
provider: "github" | "sentry";
|
|
755
|
+
kind: "pull_request" | "branch" | "commit" | "issue" | "sentry_issue";
|
|
756
|
+
url: string;
|
|
757
|
+
title: string;
|
|
758
|
+
state: TasksTaskArchiveResultSchema6;
|
|
759
|
+
closing: boolean;
|
|
760
|
+
author: TasksTaskArchiveResultSchema6;
|
|
761
|
+
repository: TasksTaskArchiveResultSchema6;
|
|
762
|
+
number: number | null;
|
|
763
|
+
updatedAt: TasksTaskArchiveResultSchema25;
|
|
764
|
+
sentry?: {
|
|
765
|
+
shortId: TasksTaskArchiveResultSchema6;
|
|
766
|
+
level: TasksTaskArchiveResultSchema6;
|
|
767
|
+
culprit: TasksTaskArchiveResultSchema6;
|
|
768
|
+
platform: TasksTaskArchiveResultSchema6;
|
|
769
|
+
project: TasksTaskArchiveResultSchema6;
|
|
770
|
+
firstSeen: TasksTaskArchiveResultSchema6;
|
|
771
|
+
lastSeen: TasksTaskArchiveResultSchema6;
|
|
772
|
+
events: TasksTaskArchiveResultSchema12 | null;
|
|
773
|
+
users: TasksTaskArchiveResultSchema12 | null;
|
|
774
|
+
countsAt: TasksTaskArchiveResultSchema6;
|
|
775
|
+
sentryState: TasksTaskArchiveResultSchema6;
|
|
776
|
+
sentryAction: TasksTaskArchiveResultSchema6;
|
|
777
|
+
} | null;
|
|
778
|
+
}>;
|
|
779
|
+
};
|
|
780
|
+
export type TasksTaskListResultSchema0 = 0 | 1 | 2 | 3 | 4;
|
|
781
|
+
export type TasksTaskListResultSchema1 = string | null;
|
|
782
|
+
export type TasksTaskListResultSchema2 = "gray" | "red" | "orange" | "amber" | "green" | "teal" | "blue" | "indigo" | "purple" | "pink";
|
|
783
|
+
export type TasksTaskListResultSchema3 = number;
|
|
784
|
+
export type TasksTaskListResultSchema4 = number;
|
|
785
|
+
export type TasksTaskListResultSchema5 = {
|
|
786
|
+
kind: "never";
|
|
787
|
+
} | {
|
|
788
|
+
kind: "until";
|
|
789
|
+
date: string;
|
|
790
|
+
} | {
|
|
791
|
+
kind: "count";
|
|
792
|
+
count: number;
|
|
793
|
+
};
|
|
794
|
+
export type TasksTaskListResultSchema6 = 1 | 2 | 3 | 4 | 5 | 6 | 7;
|
|
795
|
+
export type TasksTaskListResultSchema7 = "yearly";
|
|
796
|
+
export type TasksTaskListResultSchema8 = number;
|
|
797
|
+
export type TasksTaskListResultSchema9 = number;
|
|
798
|
+
export type TasksTaskListResultSchema10 = string;
|
|
799
|
+
export type TasksTaskListResult = {
|
|
800
|
+
data: Array<{
|
|
801
|
+
id: string;
|
|
802
|
+
identifier: string;
|
|
803
|
+
team: string;
|
|
804
|
+
title: string;
|
|
805
|
+
status: {
|
|
806
|
+
id: string;
|
|
807
|
+
name: string;
|
|
808
|
+
category: "backlog" | "unstarted" | "started" | "completed" | "canceled";
|
|
809
|
+
};
|
|
810
|
+
priority: TasksTaskListResultSchema0;
|
|
811
|
+
assignee: TasksTaskListResultSchema1;
|
|
812
|
+
dueDate: string | null;
|
|
813
|
+
overdue: boolean;
|
|
814
|
+
labels: Array<{
|
|
815
|
+
id: string;
|
|
816
|
+
name: string;
|
|
817
|
+
color: TasksTaskListResultSchema2;
|
|
818
|
+
group?: {
|
|
819
|
+
id: string;
|
|
820
|
+
name: string;
|
|
821
|
+
exclusive: boolean;
|
|
822
|
+
} | null;
|
|
823
|
+
}>;
|
|
824
|
+
parent: string | null;
|
|
825
|
+
subtasks: {
|
|
826
|
+
total: TasksTaskListResultSchema3;
|
|
827
|
+
done: TasksTaskListResultSchema3;
|
|
828
|
+
};
|
|
829
|
+
project?: {
|
|
830
|
+
id: string;
|
|
831
|
+
name: string;
|
|
832
|
+
color: TasksTaskListResultSchema2;
|
|
833
|
+
archived: boolean;
|
|
834
|
+
} | null;
|
|
835
|
+
milestone?: {
|
|
836
|
+
id: string;
|
|
837
|
+
name: string;
|
|
838
|
+
position: number;
|
|
839
|
+
} | null;
|
|
840
|
+
series?: {
|
|
841
|
+
id: string;
|
|
842
|
+
seq: TasksTaskListResultSchema3;
|
|
843
|
+
live: boolean;
|
|
844
|
+
status: "active" | "paused" | "ended";
|
|
845
|
+
mode: "schedule" | "completion";
|
|
846
|
+
rule: {
|
|
847
|
+
freq: "daily";
|
|
848
|
+
interval: TasksTaskListResultSchema4;
|
|
849
|
+
end: TasksTaskListResultSchema5;
|
|
850
|
+
} | {
|
|
851
|
+
freq: "weekly";
|
|
852
|
+
interval: TasksTaskListResultSchema4;
|
|
853
|
+
end: TasksTaskListResultSchema5;
|
|
854
|
+
weekdays: Array<TasksTaskListResultSchema6>;
|
|
855
|
+
} | {
|
|
856
|
+
freq: "monthly";
|
|
857
|
+
interval: TasksTaskListResultSchema4;
|
|
858
|
+
end: TasksTaskListResultSchema5;
|
|
859
|
+
monthDay: "last" | number;
|
|
860
|
+
} | {
|
|
861
|
+
freq: TasksTaskListResultSchema7;
|
|
862
|
+
interval: TasksTaskListResultSchema4;
|
|
863
|
+
end: TasksTaskListResultSchema5;
|
|
864
|
+
month: TasksTaskListResultSchema8;
|
|
865
|
+
day: TasksTaskListResultSchema9;
|
|
866
|
+
};
|
|
867
|
+
anchorDate: string;
|
|
868
|
+
model: {
|
|
869
|
+
title: string;
|
|
870
|
+
descriptionMd: string;
|
|
871
|
+
assignee: TasksTaskListResultSchema1;
|
|
872
|
+
priority: TasksTaskListResultSchema0;
|
|
873
|
+
labelIds: Array<string>;
|
|
874
|
+
projectId: string | null;
|
|
875
|
+
subtasks: Array<{
|
|
876
|
+
title: string;
|
|
877
|
+
assignee: TasksTaskListResultSchema1;
|
|
878
|
+
priority: TasksTaskListResultSchema0;
|
|
879
|
+
}>;
|
|
880
|
+
};
|
|
881
|
+
} | null;
|
|
882
|
+
blocked: boolean;
|
|
883
|
+
blockedVia: "self" | "parent" | "both" | null;
|
|
884
|
+
blockedParent: TasksTaskListResultSchema1;
|
|
885
|
+
archived: boolean;
|
|
886
|
+
updatedAt: TasksTaskListResultSchema10;
|
|
887
|
+
createdAt: TasksTaskListResultSchema10;
|
|
888
|
+
}>;
|
|
889
|
+
nextCursor: string | null;
|
|
890
|
+
total: TasksTaskListResultSchema3;
|
|
891
|
+
};
|
|
892
|
+
export type TasksTeamListResultSchema0 = string | null;
|
|
893
|
+
export type TasksTeamListResultSchema1 = number;
|
|
894
|
+
export type TasksTeamListResult = {
|
|
895
|
+
data: Array<{
|
|
896
|
+
id: string;
|
|
897
|
+
key: string;
|
|
898
|
+
name: string;
|
|
899
|
+
description: TasksTeamListResultSchema0;
|
|
900
|
+
kind: "team" | "personal";
|
|
901
|
+
owner: TasksTeamListResultSchema0;
|
|
902
|
+
ownerName: TasksTeamListResultSchema0;
|
|
903
|
+
ownerImage: TasksTeamListResultSchema0;
|
|
904
|
+
archived: boolean;
|
|
905
|
+
version: TasksTeamListResultSchema1;
|
|
906
|
+
access: "member" | "admin";
|
|
907
|
+
openTasks: TasksTeamListResultSchema1;
|
|
908
|
+
members: TasksTeamListResultSchema1;
|
|
909
|
+
activeProjects: TasksTeamListResultSchema1;
|
|
910
|
+
taskCounts: {
|
|
911
|
+
[key: string]: TasksTeamListResultSchema1;
|
|
912
|
+
};
|
|
913
|
+
triage: {
|
|
914
|
+
enabled: boolean;
|
|
915
|
+
pending: TasksTeamListResultSchema1;
|
|
916
|
+
held: TasksTeamListResultSchema1;
|
|
917
|
+
filtered: TasksTeamListResultSchema1;
|
|
918
|
+
} | null;
|
|
919
|
+
}>;
|
|
920
|
+
nextCursor: null;
|
|
921
|
+
};
|
|
922
|
+
export type EventsListErasuresData = {
|
|
923
|
+
body?: never;
|
|
924
|
+
path?: never;
|
|
925
|
+
query?: {
|
|
926
|
+
status?: "pending" | "done";
|
|
927
|
+
/**
|
|
928
|
+
* Opaque cursor returned by the previous page.
|
|
929
|
+
*/
|
|
930
|
+
cursor?: string;
|
|
931
|
+
};
|
|
932
|
+
url: "/v1/events/erasures";
|
|
933
|
+
};
|
|
934
|
+
export type EventsListErasuresErrors = {
|
|
935
|
+
/**
|
|
936
|
+
* api.invalid_key
|
|
937
|
+
*/
|
|
938
|
+
401: ErrorEnvelope;
|
|
939
|
+
/**
|
|
940
|
+
* api.insufficient_scope, api.forbidden
|
|
941
|
+
*/
|
|
942
|
+
403: ErrorEnvelope;
|
|
943
|
+
/**
|
|
944
|
+
* api.module_unavailable
|
|
945
|
+
*/
|
|
946
|
+
404: ErrorEnvelope;
|
|
947
|
+
/**
|
|
948
|
+
* api.invalid_input
|
|
949
|
+
*/
|
|
950
|
+
422: ErrorEnvelope;
|
|
951
|
+
/**
|
|
952
|
+
* api.rate_limited
|
|
953
|
+
*/
|
|
954
|
+
429: ErrorEnvelope;
|
|
955
|
+
/**
|
|
956
|
+
* api.internal
|
|
957
|
+
*/
|
|
958
|
+
500: ErrorEnvelope;
|
|
959
|
+
/**
|
|
960
|
+
* api.workspace_preparing
|
|
961
|
+
*/
|
|
962
|
+
503: ErrorEnvelope;
|
|
963
|
+
};
|
|
964
|
+
export type EventsListErasuresError = EventsListErasuresErrors[keyof EventsListErasuresErrors];
|
|
965
|
+
export type EventsListErasuresResponses = {
|
|
966
|
+
/**
|
|
967
|
+
* Success
|
|
968
|
+
*/
|
|
969
|
+
200: EventsListErasuresResult;
|
|
970
|
+
};
|
|
971
|
+
export type EventsListErasuresResponse = EventsListErasuresResponses[keyof EventsListErasuresResponses];
|
|
972
|
+
export type EventsErasePersonData = {
|
|
973
|
+
body: {
|
|
974
|
+
requestKey: string;
|
|
975
|
+
userId?: string;
|
|
976
|
+
anonymousIds?: Array<string>;
|
|
977
|
+
email?: string;
|
|
978
|
+
};
|
|
979
|
+
headers?: {
|
|
980
|
+
"Idempotency-Key"?: string;
|
|
981
|
+
};
|
|
982
|
+
path?: never;
|
|
983
|
+
query?: never;
|
|
984
|
+
url: "/v1/events/erasures";
|
|
985
|
+
};
|
|
986
|
+
export type EventsErasePersonErrors = {
|
|
987
|
+
/**
|
|
988
|
+
* api.invalid_json
|
|
989
|
+
*/
|
|
990
|
+
400: ErrorEnvelope;
|
|
991
|
+
/**
|
|
992
|
+
* api.invalid_key
|
|
993
|
+
*/
|
|
994
|
+
401: ErrorEnvelope;
|
|
995
|
+
/**
|
|
996
|
+
* api.insufficient_scope, api.forbidden
|
|
997
|
+
*/
|
|
998
|
+
403: ErrorEnvelope;
|
|
999
|
+
/**
|
|
1000
|
+
* api.module_unavailable
|
|
1001
|
+
*/
|
|
1002
|
+
404: ErrorEnvelope;
|
|
1003
|
+
/**
|
|
1004
|
+
* api.idempotency_in_progress, events.erasure_request_key_conflict
|
|
1005
|
+
*/
|
|
1006
|
+
409: ErrorEnvelope;
|
|
1007
|
+
/**
|
|
1008
|
+
* api.payload_too_large
|
|
1009
|
+
*/
|
|
1010
|
+
413: ErrorEnvelope;
|
|
1011
|
+
/**
|
|
1012
|
+
* api.unsupported_media_type
|
|
1013
|
+
*/
|
|
1014
|
+
415: ErrorEnvelope;
|
|
1015
|
+
/**
|
|
1016
|
+
* api.invalid_input, api.idempotency_key_reused
|
|
1017
|
+
*/
|
|
1018
|
+
422: ErrorEnvelope;
|
|
1019
|
+
/**
|
|
1020
|
+
* api.rate_limited
|
|
1021
|
+
*/
|
|
1022
|
+
429: ErrorEnvelope;
|
|
1023
|
+
/**
|
|
1024
|
+
* api.internal
|
|
1025
|
+
*/
|
|
1026
|
+
500: ErrorEnvelope;
|
|
1027
|
+
/**
|
|
1028
|
+
* api.workspace_preparing
|
|
1029
|
+
*/
|
|
1030
|
+
503: ErrorEnvelope;
|
|
1031
|
+
};
|
|
1032
|
+
export type EventsErasePersonError = EventsErasePersonErrors[keyof EventsErasePersonErrors];
|
|
1033
|
+
export type EventsErasePersonResponses = {
|
|
1034
|
+
/**
|
|
1035
|
+
* Success
|
|
1036
|
+
*/
|
|
1037
|
+
201: EventsErasePersonResult;
|
|
1038
|
+
};
|
|
1039
|
+
export type EventsErasePersonResponse = EventsErasePersonResponses[keyof EventsErasePersonResponses];
|
|
1040
|
+
export type EventsGetCatalogEntryData = {
|
|
1041
|
+
body?: never;
|
|
1042
|
+
path?: never;
|
|
1043
|
+
query: {
|
|
1044
|
+
type: string;
|
|
1045
|
+
name: string;
|
|
1046
|
+
};
|
|
1047
|
+
url: "/v1/events/catalog/entry";
|
|
1048
|
+
};
|
|
1049
|
+
export type EventsGetCatalogEntryErrors = {
|
|
1050
|
+
/**
|
|
1051
|
+
* api.invalid_key
|
|
1052
|
+
*/
|
|
1053
|
+
401: ErrorEnvelope;
|
|
1054
|
+
/**
|
|
1055
|
+
* api.insufficient_scope, api.forbidden
|
|
1056
|
+
*/
|
|
1057
|
+
403: ErrorEnvelope;
|
|
1058
|
+
/**
|
|
1059
|
+
* api.module_unavailable, platform.not_found
|
|
1060
|
+
*/
|
|
1061
|
+
404: ErrorEnvelope;
|
|
1062
|
+
/**
|
|
1063
|
+
* api.invalid_input
|
|
1064
|
+
*/
|
|
1065
|
+
422: ErrorEnvelope;
|
|
1066
|
+
/**
|
|
1067
|
+
* api.rate_limited
|
|
1068
|
+
*/
|
|
1069
|
+
429: ErrorEnvelope;
|
|
1070
|
+
/**
|
|
1071
|
+
* api.internal
|
|
1072
|
+
*/
|
|
1073
|
+
500: ErrorEnvelope;
|
|
1074
|
+
/**
|
|
1075
|
+
* api.workspace_preparing
|
|
1076
|
+
*/
|
|
1077
|
+
503: ErrorEnvelope;
|
|
1078
|
+
};
|
|
1079
|
+
export type EventsGetCatalogEntryError = EventsGetCatalogEntryErrors[keyof EventsGetCatalogEntryErrors];
|
|
1080
|
+
export type EventsGetCatalogEntryResponses = {
|
|
1081
|
+
/**
|
|
1082
|
+
* Success
|
|
1083
|
+
*/
|
|
1084
|
+
200: EventsGetCatalogEntryResult;
|
|
1085
|
+
};
|
|
1086
|
+
export type EventsGetCatalogEntryResponse = EventsGetCatalogEntryResponses[keyof EventsGetCatalogEntryResponses];
|
|
1087
|
+
export type EventsGetErasureData = {
|
|
1088
|
+
body?: never;
|
|
1089
|
+
path: {
|
|
1090
|
+
erasureId: string;
|
|
1091
|
+
};
|
|
1092
|
+
query?: never;
|
|
1093
|
+
url: "/v1/events/erasures/{erasureId}";
|
|
1094
|
+
};
|
|
1095
|
+
export type EventsGetErasureErrors = {
|
|
1096
|
+
/**
|
|
1097
|
+
* api.invalid_key
|
|
1098
|
+
*/
|
|
1099
|
+
401: ErrorEnvelope;
|
|
1100
|
+
/**
|
|
1101
|
+
* api.insufficient_scope, api.forbidden
|
|
1102
|
+
*/
|
|
1103
|
+
403: ErrorEnvelope;
|
|
1104
|
+
/**
|
|
1105
|
+
* api.module_unavailable, platform.not_found
|
|
1106
|
+
*/
|
|
1107
|
+
404: ErrorEnvelope;
|
|
1108
|
+
/**
|
|
1109
|
+
* api.invalid_input
|
|
1110
|
+
*/
|
|
1111
|
+
422: ErrorEnvelope;
|
|
1112
|
+
/**
|
|
1113
|
+
* api.rate_limited
|
|
1114
|
+
*/
|
|
1115
|
+
429: ErrorEnvelope;
|
|
1116
|
+
/**
|
|
1117
|
+
* api.internal
|
|
1118
|
+
*/
|
|
1119
|
+
500: ErrorEnvelope;
|
|
1120
|
+
/**
|
|
1121
|
+
* api.workspace_preparing
|
|
1122
|
+
*/
|
|
1123
|
+
503: ErrorEnvelope;
|
|
1124
|
+
};
|
|
1125
|
+
export type EventsGetErasureError = EventsGetErasureErrors[keyof EventsGetErasureErrors];
|
|
1126
|
+
export type EventsGetErasureResponses = {
|
|
1127
|
+
/**
|
|
1128
|
+
* Success
|
|
1129
|
+
*/
|
|
1130
|
+
200: EventsGetErasureResult;
|
|
1131
|
+
};
|
|
1132
|
+
export type EventsGetErasureResponse = EventsGetErasureResponses[keyof EventsGetErasureResponses];
|
|
1133
|
+
export type EventsGetEventData = {
|
|
1134
|
+
body?: never;
|
|
1135
|
+
path: {
|
|
1136
|
+
eventId: string;
|
|
1137
|
+
};
|
|
1138
|
+
query?: never;
|
|
1139
|
+
url: "/v1/events/events/{eventId}";
|
|
1140
|
+
};
|
|
1141
|
+
export type EventsGetEventErrors = {
|
|
1142
|
+
/**
|
|
1143
|
+
* api.invalid_key
|
|
1144
|
+
*/
|
|
1145
|
+
401: ErrorEnvelope;
|
|
1146
|
+
/**
|
|
1147
|
+
* api.insufficient_scope, api.forbidden
|
|
1148
|
+
*/
|
|
1149
|
+
403: ErrorEnvelope;
|
|
1150
|
+
/**
|
|
1151
|
+
* api.module_unavailable, platform.not_found
|
|
1152
|
+
*/
|
|
1153
|
+
404: ErrorEnvelope;
|
|
1154
|
+
/**
|
|
1155
|
+
* api.invalid_input
|
|
1156
|
+
*/
|
|
1157
|
+
422: ErrorEnvelope;
|
|
1158
|
+
/**
|
|
1159
|
+
* api.rate_limited
|
|
1160
|
+
*/
|
|
1161
|
+
429: ErrorEnvelope;
|
|
1162
|
+
/**
|
|
1163
|
+
* api.internal
|
|
1164
|
+
*/
|
|
1165
|
+
500: ErrorEnvelope;
|
|
1166
|
+
/**
|
|
1167
|
+
* api.workspace_preparing
|
|
1168
|
+
*/
|
|
1169
|
+
503: ErrorEnvelope;
|
|
1170
|
+
};
|
|
1171
|
+
export type EventsGetEventError = EventsGetEventErrors[keyof EventsGetEventErrors];
|
|
1172
|
+
export type EventsGetEventResponses = {
|
|
1173
|
+
/**
|
|
1174
|
+
* Success
|
|
1175
|
+
*/
|
|
1176
|
+
200: EventsGetEventResult;
|
|
1177
|
+
};
|
|
1178
|
+
export type EventsGetEventResponse = EventsGetEventResponses[keyof EventsGetEventResponses];
|
|
1179
|
+
export type EventsGetSourceData = {
|
|
1180
|
+
body?: never;
|
|
1181
|
+
path: {
|
|
1182
|
+
sourceId: string;
|
|
1183
|
+
};
|
|
1184
|
+
query?: never;
|
|
1185
|
+
url: "/v1/events/sources/{sourceId}";
|
|
1186
|
+
};
|
|
1187
|
+
export type EventsGetSourceErrors = {
|
|
1188
|
+
/**
|
|
1189
|
+
* api.invalid_key
|
|
1190
|
+
*/
|
|
1191
|
+
401: ErrorEnvelope;
|
|
1192
|
+
/**
|
|
1193
|
+
* api.insufficient_scope, api.forbidden
|
|
1194
|
+
*/
|
|
1195
|
+
403: ErrorEnvelope;
|
|
1196
|
+
/**
|
|
1197
|
+
* api.module_unavailable, platform.not_found
|
|
1198
|
+
*/
|
|
1199
|
+
404: ErrorEnvelope;
|
|
1200
|
+
/**
|
|
1201
|
+
* api.invalid_input
|
|
1202
|
+
*/
|
|
1203
|
+
422: ErrorEnvelope;
|
|
1204
|
+
/**
|
|
1205
|
+
* api.rate_limited
|
|
1206
|
+
*/
|
|
1207
|
+
429: ErrorEnvelope;
|
|
1208
|
+
/**
|
|
1209
|
+
* api.internal
|
|
1210
|
+
*/
|
|
1211
|
+
500: ErrorEnvelope;
|
|
1212
|
+
/**
|
|
1213
|
+
* api.workspace_preparing
|
|
1214
|
+
*/
|
|
1215
|
+
503: ErrorEnvelope;
|
|
1216
|
+
};
|
|
1217
|
+
export type EventsGetSourceError = EventsGetSourceErrors[keyof EventsGetSourceErrors];
|
|
1218
|
+
export type EventsGetSourceResponses = {
|
|
1219
|
+
/**
|
|
1220
|
+
* Success
|
|
1221
|
+
*/
|
|
1222
|
+
200: EventsGetSourceResult;
|
|
1223
|
+
};
|
|
1224
|
+
export type EventsGetSourceResponse = EventsGetSourceResponses[keyof EventsGetSourceResponses];
|
|
1225
|
+
export type EventsListCatalogData = {
|
|
1226
|
+
body?: never;
|
|
1227
|
+
path?: never;
|
|
1228
|
+
query?: {
|
|
1229
|
+
sort?: "name" | "volume7d" | "violations7d" | "lastSeenAt";
|
|
1230
|
+
direction?: "asc" | "desc";
|
|
1231
|
+
withViolations?: boolean;
|
|
1232
|
+
query?: string;
|
|
1233
|
+
lane?: "behavior" | "domain" | "all";
|
|
1234
|
+
status?: "visible" | "hidden" | "blocked";
|
|
1235
|
+
/**
|
|
1236
|
+
* Opaque cursor returned by the previous page.
|
|
1237
|
+
*/
|
|
1238
|
+
cursor?: string;
|
|
1239
|
+
};
|
|
1240
|
+
url: "/v1/events/catalog";
|
|
1241
|
+
};
|
|
1242
|
+
export type EventsListCatalogErrors = {
|
|
1243
|
+
/**
|
|
1244
|
+
* api.invalid_key
|
|
1245
|
+
*/
|
|
1246
|
+
401: ErrorEnvelope;
|
|
1247
|
+
/**
|
|
1248
|
+
* api.insufficient_scope, api.forbidden
|
|
1249
|
+
*/
|
|
1250
|
+
403: ErrorEnvelope;
|
|
1251
|
+
/**
|
|
1252
|
+
* api.module_unavailable
|
|
1253
|
+
*/
|
|
1254
|
+
404: ErrorEnvelope;
|
|
1255
|
+
/**
|
|
1256
|
+
* api.invalid_input
|
|
1257
|
+
*/
|
|
1258
|
+
422: ErrorEnvelope;
|
|
1259
|
+
/**
|
|
1260
|
+
* api.rate_limited
|
|
1261
|
+
*/
|
|
1262
|
+
429: ErrorEnvelope;
|
|
1263
|
+
/**
|
|
1264
|
+
* api.internal
|
|
1265
|
+
*/
|
|
1266
|
+
500: ErrorEnvelope;
|
|
1267
|
+
/**
|
|
1268
|
+
* api.workspace_preparing
|
|
1269
|
+
*/
|
|
1270
|
+
503: ErrorEnvelope;
|
|
1271
|
+
};
|
|
1272
|
+
export type EventsListCatalogError = EventsListCatalogErrors[keyof EventsListCatalogErrors];
|
|
1273
|
+
export type EventsListCatalogResponses = {
|
|
1274
|
+
/**
|
|
1275
|
+
* Success
|
|
1276
|
+
*/
|
|
1277
|
+
200: EventsListCatalogResult;
|
|
1278
|
+
};
|
|
1279
|
+
export type EventsListCatalogResponse = EventsListCatalogResponses[keyof EventsListCatalogResponses];
|
|
1280
|
+
export type EventsListDeliveriesData = {
|
|
1281
|
+
body?: never;
|
|
1282
|
+
path?: never;
|
|
1283
|
+
query?: {
|
|
1284
|
+
status?: "pending" | "processing" | "delivered" | "failed" | "skipped" | "expired" | "replayed";
|
|
1285
|
+
consumer?: string;
|
|
1286
|
+
/**
|
|
1287
|
+
* Opaque cursor returned by the previous page.
|
|
1288
|
+
*/
|
|
1289
|
+
cursor?: string;
|
|
1290
|
+
};
|
|
1291
|
+
url: "/v1/events/deliveries";
|
|
1292
|
+
};
|
|
1293
|
+
export type EventsListDeliveriesErrors = {
|
|
1294
|
+
/**
|
|
1295
|
+
* api.invalid_key
|
|
1296
|
+
*/
|
|
1297
|
+
401: ErrorEnvelope;
|
|
1298
|
+
/**
|
|
1299
|
+
* api.insufficient_scope, api.forbidden
|
|
1300
|
+
*/
|
|
1301
|
+
403: ErrorEnvelope;
|
|
1302
|
+
/**
|
|
1303
|
+
* api.module_unavailable
|
|
1304
|
+
*/
|
|
1305
|
+
404: ErrorEnvelope;
|
|
1306
|
+
/**
|
|
1307
|
+
* api.invalid_input
|
|
1308
|
+
*/
|
|
1309
|
+
422: ErrorEnvelope;
|
|
1310
|
+
/**
|
|
1311
|
+
* api.rate_limited
|
|
1312
|
+
*/
|
|
1313
|
+
429: ErrorEnvelope;
|
|
1314
|
+
/**
|
|
1315
|
+
* api.internal
|
|
1316
|
+
*/
|
|
1317
|
+
500: ErrorEnvelope;
|
|
1318
|
+
/**
|
|
1319
|
+
* api.workspace_preparing
|
|
1320
|
+
*/
|
|
1321
|
+
503: ErrorEnvelope;
|
|
1322
|
+
};
|
|
1323
|
+
export type EventsListDeliveriesError = EventsListDeliveriesErrors[keyof EventsListDeliveriesErrors];
|
|
1324
|
+
export type EventsListDeliveriesResponses = {
|
|
1325
|
+
/**
|
|
1326
|
+
* Success
|
|
1327
|
+
*/
|
|
1328
|
+
200: EventsListDeliveriesResult;
|
|
1329
|
+
};
|
|
1330
|
+
export type EventsListDeliveriesResponse = EventsListDeliveriesResponses[keyof EventsListDeliveriesResponses];
|
|
1331
|
+
export type EventsListGapsData = {
|
|
1332
|
+
body?: never;
|
|
1333
|
+
path?: never;
|
|
1334
|
+
query?: {
|
|
1335
|
+
open?: boolean;
|
|
1336
|
+
};
|
|
1337
|
+
url: "/v1/events/gaps";
|
|
1338
|
+
};
|
|
1339
|
+
export type EventsListGapsErrors = {
|
|
1340
|
+
/**
|
|
1341
|
+
* api.invalid_key
|
|
1342
|
+
*/
|
|
1343
|
+
401: ErrorEnvelope;
|
|
1344
|
+
/**
|
|
1345
|
+
* api.insufficient_scope, api.forbidden
|
|
1346
|
+
*/
|
|
1347
|
+
403: ErrorEnvelope;
|
|
1348
|
+
/**
|
|
1349
|
+
* api.module_unavailable
|
|
1350
|
+
*/
|
|
1351
|
+
404: ErrorEnvelope;
|
|
1352
|
+
/**
|
|
1353
|
+
* api.invalid_input
|
|
1354
|
+
*/
|
|
1355
|
+
422: ErrorEnvelope;
|
|
1356
|
+
/**
|
|
1357
|
+
* api.rate_limited
|
|
1358
|
+
*/
|
|
1359
|
+
429: ErrorEnvelope;
|
|
1360
|
+
/**
|
|
1361
|
+
* api.internal
|
|
1362
|
+
*/
|
|
1363
|
+
500: ErrorEnvelope;
|
|
1364
|
+
/**
|
|
1365
|
+
* api.workspace_preparing
|
|
1366
|
+
*/
|
|
1367
|
+
503: ErrorEnvelope;
|
|
1368
|
+
};
|
|
1369
|
+
export type EventsListGapsError = EventsListGapsErrors[keyof EventsListGapsErrors];
|
|
1370
|
+
export type EventsListGapsResponses = {
|
|
1371
|
+
/**
|
|
1372
|
+
* Success
|
|
1373
|
+
*/
|
|
1374
|
+
200: EventsListGapsResult;
|
|
1375
|
+
};
|
|
1376
|
+
export type EventsListGapsResponse = EventsListGapsResponses[keyof EventsListGapsResponses];
|
|
1377
|
+
export type EventsListSourcesData = {
|
|
1378
|
+
body?: never;
|
|
1379
|
+
path?: never;
|
|
1380
|
+
query?: never;
|
|
1381
|
+
url: "/v1/events/sources";
|
|
1382
|
+
};
|
|
1383
|
+
export type EventsListSourcesErrors = {
|
|
1384
|
+
/**
|
|
1385
|
+
* api.invalid_key
|
|
1386
|
+
*/
|
|
1387
|
+
401: ErrorEnvelope;
|
|
1388
|
+
/**
|
|
1389
|
+
* api.insufficient_scope, api.forbidden
|
|
1390
|
+
*/
|
|
1391
|
+
403: ErrorEnvelope;
|
|
1392
|
+
/**
|
|
1393
|
+
* api.module_unavailable
|
|
1394
|
+
*/
|
|
1395
|
+
404: ErrorEnvelope;
|
|
1396
|
+
/**
|
|
1397
|
+
* api.invalid_input
|
|
1398
|
+
*/
|
|
1399
|
+
422: ErrorEnvelope;
|
|
1400
|
+
/**
|
|
1401
|
+
* api.rate_limited
|
|
1402
|
+
*/
|
|
1403
|
+
429: ErrorEnvelope;
|
|
1404
|
+
/**
|
|
1405
|
+
* api.internal
|
|
1406
|
+
*/
|
|
1407
|
+
500: ErrorEnvelope;
|
|
1408
|
+
/**
|
|
1409
|
+
* api.workspace_preparing
|
|
1410
|
+
*/
|
|
1411
|
+
503: ErrorEnvelope;
|
|
1412
|
+
};
|
|
1413
|
+
export type EventsListSourcesError = EventsListSourcesErrors[keyof EventsListSourcesErrors];
|
|
1414
|
+
export type EventsListSourcesResponses = {
|
|
1415
|
+
/**
|
|
1416
|
+
* Success
|
|
1417
|
+
*/
|
|
1418
|
+
200: EventsListSourcesResult;
|
|
1419
|
+
};
|
|
1420
|
+
export type EventsListSourcesResponse = EventsListSourcesResponses[keyof EventsListSourcesResponses];
|
|
1421
|
+
export type EventsSearchData = {
|
|
1422
|
+
body: {
|
|
1423
|
+
userId?: string;
|
|
1424
|
+
anonymousId?: string;
|
|
1425
|
+
name?: string;
|
|
1426
|
+
sourceId?: string;
|
|
1427
|
+
from: string;
|
|
1428
|
+
to: string;
|
|
1429
|
+
limit?: number;
|
|
1430
|
+
};
|
|
1431
|
+
path?: never;
|
|
1432
|
+
query?: never;
|
|
1433
|
+
url: "/v1/events/events/search";
|
|
1434
|
+
};
|
|
1435
|
+
export type EventsSearchErrors = {
|
|
1436
|
+
/**
|
|
1437
|
+
* api.invalid_json
|
|
1438
|
+
*/
|
|
1439
|
+
400: ErrorEnvelope;
|
|
1440
|
+
/**
|
|
1441
|
+
* api.invalid_key
|
|
1442
|
+
*/
|
|
1443
|
+
401: ErrorEnvelope;
|
|
1444
|
+
/**
|
|
1445
|
+
* api.insufficient_scope, api.forbidden, platform.forbidden
|
|
1446
|
+
*/
|
|
1447
|
+
403: ErrorEnvelope;
|
|
1448
|
+
/**
|
|
1449
|
+
* api.module_unavailable
|
|
1450
|
+
*/
|
|
1451
|
+
404: ErrorEnvelope;
|
|
1452
|
+
/**
|
|
1453
|
+
* api.payload_too_large
|
|
1454
|
+
*/
|
|
1455
|
+
413: ErrorEnvelope;
|
|
1456
|
+
/**
|
|
1457
|
+
* api.unsupported_media_type
|
|
1458
|
+
*/
|
|
1459
|
+
415: ErrorEnvelope;
|
|
1460
|
+
/**
|
|
1461
|
+
* api.invalid_input
|
|
1462
|
+
*/
|
|
1463
|
+
422: ErrorEnvelope;
|
|
1464
|
+
/**
|
|
1465
|
+
* api.rate_limited
|
|
1466
|
+
*/
|
|
1467
|
+
429: ErrorEnvelope;
|
|
1468
|
+
/**
|
|
1469
|
+
* api.internal
|
|
1470
|
+
*/
|
|
1471
|
+
500: ErrorEnvelope;
|
|
1472
|
+
/**
|
|
1473
|
+
* api.workspace_preparing, events.store_unavailable
|
|
1474
|
+
*/
|
|
1475
|
+
503: ErrorEnvelope;
|
|
1476
|
+
};
|
|
1477
|
+
export type EventsSearchError = EventsSearchErrors[keyof EventsSearchErrors];
|
|
1478
|
+
export type EventsSearchResponses = {
|
|
1479
|
+
/**
|
|
1480
|
+
* Success
|
|
1481
|
+
*/
|
|
1482
|
+
200: EventsSearchResult;
|
|
1483
|
+
};
|
|
1484
|
+
export type EventsSearchResponse = EventsSearchResponses[keyof EventsSearchResponses];
|
|
1485
|
+
export type EventsStatusData = {
|
|
1486
|
+
body?: never;
|
|
1487
|
+
path?: never;
|
|
1488
|
+
query?: never;
|
|
1489
|
+
url: "/v1/events/status";
|
|
1490
|
+
};
|
|
1491
|
+
export type EventsStatusErrors = {
|
|
1492
|
+
/**
|
|
1493
|
+
* api.invalid_key
|
|
1494
|
+
*/
|
|
1495
|
+
401: ErrorEnvelope;
|
|
1496
|
+
/**
|
|
1497
|
+
* api.insufficient_scope, api.forbidden
|
|
1498
|
+
*/
|
|
1499
|
+
403: ErrorEnvelope;
|
|
1500
|
+
/**
|
|
1501
|
+
* api.module_unavailable
|
|
1502
|
+
*/
|
|
1503
|
+
404: ErrorEnvelope;
|
|
1504
|
+
/**
|
|
1505
|
+
* api.invalid_input
|
|
1506
|
+
*/
|
|
1507
|
+
422: ErrorEnvelope;
|
|
1508
|
+
/**
|
|
1509
|
+
* api.rate_limited
|
|
1510
|
+
*/
|
|
1511
|
+
429: ErrorEnvelope;
|
|
1512
|
+
/**
|
|
1513
|
+
* api.internal
|
|
1514
|
+
*/
|
|
1515
|
+
500: ErrorEnvelope;
|
|
1516
|
+
/**
|
|
1517
|
+
* api.workspace_preparing, events.store_unavailable
|
|
1518
|
+
*/
|
|
1519
|
+
503: ErrorEnvelope;
|
|
1520
|
+
};
|
|
1521
|
+
export type EventsStatusError = EventsStatusErrors[keyof EventsStatusErrors];
|
|
1522
|
+
export type EventsStatusResponses = {
|
|
1523
|
+
/**
|
|
1524
|
+
* Success
|
|
1525
|
+
*/
|
|
1526
|
+
200: EventsStatusResult;
|
|
1527
|
+
};
|
|
1528
|
+
export type EventsStatusResponse = EventsStatusResponses[keyof EventsStatusResponses];
|
|
1529
|
+
export type ProductsAddOfferData = {
|
|
1530
|
+
body: {
|
|
1531
|
+
source: string;
|
|
1532
|
+
externalId: string;
|
|
1533
|
+
label?: string;
|
|
1534
|
+
};
|
|
1535
|
+
headers?: {
|
|
1536
|
+
"Idempotency-Key"?: string;
|
|
1537
|
+
};
|
|
1538
|
+
path: {
|
|
1539
|
+
productId: string;
|
|
1540
|
+
};
|
|
1541
|
+
query?: never;
|
|
1542
|
+
url: "/v1/products/products/{productId}/offers";
|
|
1543
|
+
};
|
|
1544
|
+
export type ProductsAddOfferErrors = {
|
|
1545
|
+
/**
|
|
1546
|
+
* api.invalid_json
|
|
1547
|
+
*/
|
|
1548
|
+
400: ErrorEnvelope;
|
|
1549
|
+
/**
|
|
1550
|
+
* api.invalid_key
|
|
1551
|
+
*/
|
|
1552
|
+
401: ErrorEnvelope;
|
|
1553
|
+
/**
|
|
1554
|
+
* api.insufficient_scope, api.forbidden
|
|
1555
|
+
*/
|
|
1556
|
+
403: ErrorEnvelope;
|
|
1557
|
+
/**
|
|
1558
|
+
* api.module_unavailable, products.not_found
|
|
1559
|
+
*/
|
|
1560
|
+
404: ErrorEnvelope;
|
|
1561
|
+
/**
|
|
1562
|
+
* api.idempotency_in_progress, products.offer_taken, products.archived
|
|
1563
|
+
*/
|
|
1564
|
+
409: ErrorEnvelope;
|
|
1565
|
+
/**
|
|
1566
|
+
* api.payload_too_large
|
|
1567
|
+
*/
|
|
1568
|
+
413: ErrorEnvelope;
|
|
1569
|
+
/**
|
|
1570
|
+
* api.unsupported_media_type
|
|
1571
|
+
*/
|
|
1572
|
+
415: ErrorEnvelope;
|
|
1573
|
+
/**
|
|
1574
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
1575
|
+
*/
|
|
1576
|
+
422: ErrorEnvelope;
|
|
1577
|
+
/**
|
|
1578
|
+
* api.rate_limited
|
|
1579
|
+
*/
|
|
1580
|
+
429: ErrorEnvelope;
|
|
1581
|
+
/**
|
|
1582
|
+
* api.internal
|
|
1583
|
+
*/
|
|
1584
|
+
500: ErrorEnvelope;
|
|
1585
|
+
/**
|
|
1586
|
+
* api.workspace_preparing
|
|
1587
|
+
*/
|
|
1588
|
+
503: ErrorEnvelope;
|
|
1589
|
+
};
|
|
1590
|
+
export type ProductsAddOfferError = ProductsAddOfferErrors[keyof ProductsAddOfferErrors];
|
|
1591
|
+
export type ProductsAddOfferResponses = {
|
|
1592
|
+
/**
|
|
1593
|
+
* Success
|
|
1594
|
+
*/
|
|
1595
|
+
200: ProductsAddOfferResult;
|
|
1596
|
+
};
|
|
1597
|
+
export type ProductsAddOfferResponse = ProductsAddOfferResponses[keyof ProductsAddOfferResponses];
|
|
1598
|
+
export type ProductsArchiveData = {
|
|
1599
|
+
body: {
|
|
1600
|
+
version: number;
|
|
1601
|
+
};
|
|
1602
|
+
headers?: {
|
|
1603
|
+
"Idempotency-Key"?: string;
|
|
1604
|
+
};
|
|
1605
|
+
path: {
|
|
1606
|
+
productId: string;
|
|
1607
|
+
};
|
|
1608
|
+
query?: never;
|
|
1609
|
+
url: "/v1/products/products/{productId}/archive";
|
|
1610
|
+
};
|
|
1611
|
+
export type ProductsArchiveErrors = {
|
|
1612
|
+
/**
|
|
1613
|
+
* api.invalid_json
|
|
1614
|
+
*/
|
|
1615
|
+
400: ErrorEnvelope;
|
|
1616
|
+
/**
|
|
1617
|
+
* api.invalid_key
|
|
1618
|
+
*/
|
|
1619
|
+
401: ErrorEnvelope;
|
|
1620
|
+
/**
|
|
1621
|
+
* api.insufficient_scope, api.forbidden
|
|
1622
|
+
*/
|
|
1623
|
+
403: ErrorEnvelope;
|
|
1624
|
+
/**
|
|
1625
|
+
* api.module_unavailable, products.not_found
|
|
1626
|
+
*/
|
|
1627
|
+
404: ErrorEnvelope;
|
|
1628
|
+
/**
|
|
1629
|
+
* api.idempotency_in_progress, products.version_conflict
|
|
1630
|
+
*/
|
|
1631
|
+
409: ErrorEnvelope;
|
|
1632
|
+
/**
|
|
1633
|
+
* api.payload_too_large
|
|
1634
|
+
*/
|
|
1635
|
+
413: ErrorEnvelope;
|
|
1636
|
+
/**
|
|
1637
|
+
* api.unsupported_media_type
|
|
1638
|
+
*/
|
|
1639
|
+
415: ErrorEnvelope;
|
|
1640
|
+
/**
|
|
1641
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
1642
|
+
*/
|
|
1643
|
+
422: ErrorEnvelope;
|
|
1644
|
+
/**
|
|
1645
|
+
* api.rate_limited
|
|
1646
|
+
*/
|
|
1647
|
+
429: ErrorEnvelope;
|
|
1648
|
+
/**
|
|
1649
|
+
* api.internal
|
|
1650
|
+
*/
|
|
1651
|
+
500: ErrorEnvelope;
|
|
1652
|
+
/**
|
|
1653
|
+
* api.workspace_preparing
|
|
1654
|
+
*/
|
|
1655
|
+
503: ErrorEnvelope;
|
|
1656
|
+
};
|
|
1657
|
+
export type ProductsArchiveError = ProductsArchiveErrors[keyof ProductsArchiveErrors];
|
|
1658
|
+
export type ProductsArchiveResponses = {
|
|
1659
|
+
/**
|
|
1660
|
+
* Success
|
|
1661
|
+
*/
|
|
1662
|
+
200: ProductsAddOfferResult;
|
|
1663
|
+
};
|
|
1664
|
+
export type ProductsArchiveResponse = ProductsArchiveResponses[keyof ProductsArchiveResponses];
|
|
1665
|
+
export type ProductsListData = {
|
|
1666
|
+
body?: never;
|
|
1667
|
+
path?: never;
|
|
1668
|
+
query?: {
|
|
1669
|
+
archived?: boolean;
|
|
1670
|
+
};
|
|
1671
|
+
url: "/v1/products/products";
|
|
1672
|
+
};
|
|
1673
|
+
export type ProductsListErrors = {
|
|
1674
|
+
/**
|
|
1675
|
+
* api.invalid_key
|
|
1676
|
+
*/
|
|
1677
|
+
401: ErrorEnvelope;
|
|
1678
|
+
/**
|
|
1679
|
+
* api.insufficient_scope, api.forbidden
|
|
1680
|
+
*/
|
|
1681
|
+
403: ErrorEnvelope;
|
|
1682
|
+
/**
|
|
1683
|
+
* api.module_unavailable
|
|
1684
|
+
*/
|
|
1685
|
+
404: ErrorEnvelope;
|
|
1686
|
+
/**
|
|
1687
|
+
* api.invalid_input
|
|
1688
|
+
*/
|
|
1689
|
+
422: ErrorEnvelope;
|
|
1690
|
+
/**
|
|
1691
|
+
* api.rate_limited
|
|
1692
|
+
*/
|
|
1693
|
+
429: ErrorEnvelope;
|
|
1694
|
+
/**
|
|
1695
|
+
* api.internal
|
|
1696
|
+
*/
|
|
1697
|
+
500: ErrorEnvelope;
|
|
1698
|
+
/**
|
|
1699
|
+
* api.workspace_preparing
|
|
1700
|
+
*/
|
|
1701
|
+
503: ErrorEnvelope;
|
|
1702
|
+
};
|
|
1703
|
+
export type ProductsListError = ProductsListErrors[keyof ProductsListErrors];
|
|
1704
|
+
export type ProductsListResponses = {
|
|
1705
|
+
/**
|
|
1706
|
+
* Success
|
|
1707
|
+
*/
|
|
1708
|
+
200: ProductsListResult;
|
|
1709
|
+
};
|
|
1710
|
+
export type ProductsListResponse = ProductsListResponses[keyof ProductsListResponses];
|
|
1711
|
+
export type ProductsCreateData = {
|
|
1712
|
+
body: {
|
|
1713
|
+
slug: string;
|
|
1714
|
+
label: string;
|
|
1715
|
+
excluded?: boolean;
|
|
1716
|
+
isDefault?: boolean;
|
|
1717
|
+
aliases?: Array<string>;
|
|
1718
|
+
};
|
|
1719
|
+
headers?: {
|
|
1720
|
+
"Idempotency-Key"?: string;
|
|
1721
|
+
};
|
|
1722
|
+
path?: never;
|
|
1723
|
+
query?: never;
|
|
1724
|
+
url: "/v1/products/products";
|
|
1725
|
+
};
|
|
1726
|
+
export type ProductsCreateErrors = {
|
|
1727
|
+
/**
|
|
1728
|
+
* api.invalid_json
|
|
1729
|
+
*/
|
|
1730
|
+
400: ErrorEnvelope;
|
|
1731
|
+
/**
|
|
1732
|
+
* api.invalid_key
|
|
1733
|
+
*/
|
|
1734
|
+
401: ErrorEnvelope;
|
|
1735
|
+
/**
|
|
1736
|
+
* api.insufficient_scope, api.forbidden
|
|
1737
|
+
*/
|
|
1738
|
+
403: ErrorEnvelope;
|
|
1739
|
+
/**
|
|
1740
|
+
* api.module_unavailable
|
|
1741
|
+
*/
|
|
1742
|
+
404: ErrorEnvelope;
|
|
1743
|
+
/**
|
|
1744
|
+
* api.idempotency_in_progress, products.slug_taken, products.slug_is_alias, products.alias_taken
|
|
1745
|
+
*/
|
|
1746
|
+
409: ErrorEnvelope;
|
|
1747
|
+
/**
|
|
1748
|
+
* api.payload_too_large
|
|
1749
|
+
*/
|
|
1750
|
+
413: ErrorEnvelope;
|
|
1751
|
+
/**
|
|
1752
|
+
* api.unsupported_media_type
|
|
1753
|
+
*/
|
|
1754
|
+
415: ErrorEnvelope;
|
|
1755
|
+
/**
|
|
1756
|
+
* api.invalid_input, api.idempotency_key_reused
|
|
1757
|
+
*/
|
|
1758
|
+
422: ErrorEnvelope;
|
|
1759
|
+
/**
|
|
1760
|
+
* api.rate_limited
|
|
1761
|
+
*/
|
|
1762
|
+
429: ErrorEnvelope;
|
|
1763
|
+
/**
|
|
1764
|
+
* api.internal
|
|
1765
|
+
*/
|
|
1766
|
+
500: ErrorEnvelope;
|
|
1767
|
+
/**
|
|
1768
|
+
* api.workspace_preparing
|
|
1769
|
+
*/
|
|
1770
|
+
503: ErrorEnvelope;
|
|
1771
|
+
};
|
|
1772
|
+
export type ProductsCreateError = ProductsCreateErrors[keyof ProductsCreateErrors];
|
|
1773
|
+
export type ProductsCreateResponses = {
|
|
1774
|
+
/**
|
|
1775
|
+
* Success
|
|
1776
|
+
*/
|
|
1777
|
+
201: ProductsAddOfferResult;
|
|
1778
|
+
};
|
|
1779
|
+
export type ProductsCreateResponse = ProductsCreateResponses[keyof ProductsCreateResponses];
|
|
1780
|
+
export type ProductsGetData = {
|
|
1781
|
+
body?: never;
|
|
1782
|
+
path: {
|
|
1783
|
+
productId: string;
|
|
1784
|
+
};
|
|
1785
|
+
query?: never;
|
|
1786
|
+
url: "/v1/products/products/{productId}";
|
|
1787
|
+
};
|
|
1788
|
+
export type ProductsGetErrors = {
|
|
1789
|
+
/**
|
|
1790
|
+
* api.invalid_key
|
|
1791
|
+
*/
|
|
1792
|
+
401: ErrorEnvelope;
|
|
1793
|
+
/**
|
|
1794
|
+
* api.insufficient_scope, api.forbidden
|
|
1795
|
+
*/
|
|
1796
|
+
403: ErrorEnvelope;
|
|
1797
|
+
/**
|
|
1798
|
+
* api.module_unavailable, products.not_found
|
|
1799
|
+
*/
|
|
1800
|
+
404: ErrorEnvelope;
|
|
1801
|
+
/**
|
|
1802
|
+
* api.invalid_input
|
|
1803
|
+
*/
|
|
1804
|
+
422: ErrorEnvelope;
|
|
1805
|
+
/**
|
|
1806
|
+
* api.rate_limited
|
|
1807
|
+
*/
|
|
1808
|
+
429: ErrorEnvelope;
|
|
1809
|
+
/**
|
|
1810
|
+
* api.internal
|
|
1811
|
+
*/
|
|
1812
|
+
500: ErrorEnvelope;
|
|
1813
|
+
/**
|
|
1814
|
+
* api.workspace_preparing
|
|
1815
|
+
*/
|
|
1816
|
+
503: ErrorEnvelope;
|
|
1817
|
+
};
|
|
1818
|
+
export type ProductsGetError = ProductsGetErrors[keyof ProductsGetErrors];
|
|
1819
|
+
export type ProductsGetResponses = {
|
|
1820
|
+
/**
|
|
1821
|
+
* Success
|
|
1822
|
+
*/
|
|
1823
|
+
200: ProductsAddOfferResult;
|
|
1824
|
+
};
|
|
1825
|
+
export type ProductsGetResponse = ProductsGetResponses[keyof ProductsGetResponses];
|
|
1826
|
+
export type ProductsUpdateData = {
|
|
1827
|
+
body: {
|
|
1828
|
+
version: number;
|
|
1829
|
+
label: string;
|
|
1830
|
+
excluded: boolean;
|
|
1831
|
+
isDefault: boolean;
|
|
1832
|
+
aliases: Array<string>;
|
|
1833
|
+
};
|
|
1834
|
+
headers?: {
|
|
1835
|
+
"Idempotency-Key"?: string;
|
|
1836
|
+
};
|
|
1837
|
+
path: {
|
|
1838
|
+
productId: string;
|
|
1839
|
+
};
|
|
1840
|
+
query?: never;
|
|
1841
|
+
url: "/v1/products/products/{productId}";
|
|
1842
|
+
};
|
|
1843
|
+
export type ProductsUpdateErrors = {
|
|
1844
|
+
/**
|
|
1845
|
+
* api.invalid_json
|
|
1846
|
+
*/
|
|
1847
|
+
400: ErrorEnvelope;
|
|
1848
|
+
/**
|
|
1849
|
+
* api.invalid_key
|
|
1850
|
+
*/
|
|
1851
|
+
401: ErrorEnvelope;
|
|
1852
|
+
/**
|
|
1853
|
+
* api.insufficient_scope, api.forbidden
|
|
1854
|
+
*/
|
|
1855
|
+
403: ErrorEnvelope;
|
|
1856
|
+
/**
|
|
1857
|
+
* api.module_unavailable, products.not_found
|
|
1858
|
+
*/
|
|
1859
|
+
404: ErrorEnvelope;
|
|
1860
|
+
/**
|
|
1861
|
+
* api.idempotency_in_progress, products.version_conflict, products.archived, products.slug_is_alias, products.alias_taken
|
|
1862
|
+
*/
|
|
1863
|
+
409: ErrorEnvelope;
|
|
1864
|
+
/**
|
|
1865
|
+
* api.payload_too_large
|
|
1866
|
+
*/
|
|
1867
|
+
413: ErrorEnvelope;
|
|
1868
|
+
/**
|
|
1869
|
+
* api.unsupported_media_type
|
|
1870
|
+
*/
|
|
1871
|
+
415: ErrorEnvelope;
|
|
1872
|
+
/**
|
|
1873
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
1874
|
+
*/
|
|
1875
|
+
422: ErrorEnvelope;
|
|
1876
|
+
/**
|
|
1877
|
+
* api.rate_limited
|
|
1878
|
+
*/
|
|
1879
|
+
429: ErrorEnvelope;
|
|
1880
|
+
/**
|
|
1881
|
+
* api.internal
|
|
1882
|
+
*/
|
|
1883
|
+
500: ErrorEnvelope;
|
|
1884
|
+
/**
|
|
1885
|
+
* api.workspace_preparing
|
|
1886
|
+
*/
|
|
1887
|
+
503: ErrorEnvelope;
|
|
1888
|
+
};
|
|
1889
|
+
export type ProductsUpdateError = ProductsUpdateErrors[keyof ProductsUpdateErrors];
|
|
1890
|
+
export type ProductsUpdateResponses = {
|
|
1891
|
+
/**
|
|
1892
|
+
* Success
|
|
1893
|
+
*/
|
|
1894
|
+
200: ProductsAddOfferResult;
|
|
1895
|
+
};
|
|
1896
|
+
export type ProductsUpdateResponse = ProductsUpdateResponses[keyof ProductsUpdateResponses];
|
|
1897
|
+
export type ProductsListAdRulesData = {
|
|
1898
|
+
body?: never;
|
|
1899
|
+
path?: never;
|
|
1900
|
+
query?: never;
|
|
1901
|
+
url: "/v1/products/ad-rules";
|
|
1902
|
+
};
|
|
1903
|
+
export type ProductsListAdRulesErrors = {
|
|
1904
|
+
/**
|
|
1905
|
+
* api.invalid_key
|
|
1906
|
+
*/
|
|
1907
|
+
401: ErrorEnvelope;
|
|
1908
|
+
/**
|
|
1909
|
+
* api.insufficient_scope, api.forbidden
|
|
1910
|
+
*/
|
|
1911
|
+
403: ErrorEnvelope;
|
|
1912
|
+
/**
|
|
1913
|
+
* api.module_unavailable
|
|
1914
|
+
*/
|
|
1915
|
+
404: ErrorEnvelope;
|
|
1916
|
+
/**
|
|
1917
|
+
* api.invalid_input
|
|
1918
|
+
*/
|
|
1919
|
+
422: ErrorEnvelope;
|
|
1920
|
+
/**
|
|
1921
|
+
* api.rate_limited
|
|
1922
|
+
*/
|
|
1923
|
+
429: ErrorEnvelope;
|
|
1924
|
+
/**
|
|
1925
|
+
* api.internal
|
|
1926
|
+
*/
|
|
1927
|
+
500: ErrorEnvelope;
|
|
1928
|
+
/**
|
|
1929
|
+
* api.workspace_preparing
|
|
1930
|
+
*/
|
|
1931
|
+
503: ErrorEnvelope;
|
|
1932
|
+
};
|
|
1933
|
+
export type ProductsListAdRulesError = ProductsListAdRulesErrors[keyof ProductsListAdRulesErrors];
|
|
1934
|
+
export type ProductsListAdRulesResponses = {
|
|
1935
|
+
/**
|
|
1936
|
+
* Success
|
|
1937
|
+
*/
|
|
1938
|
+
200: ProductsListAdRulesResult;
|
|
1939
|
+
};
|
|
1940
|
+
export type ProductsListAdRulesResponse = ProductsListAdRulesResponses[keyof ProductsListAdRulesResponses];
|
|
1941
|
+
export type ProductsSaveAdRuleCreateAdRuleData = {
|
|
1942
|
+
body: {
|
|
1943
|
+
productId: string;
|
|
1944
|
+
pattern: string;
|
|
1945
|
+
matchType: "contains" | "prefix" | "regex";
|
|
1946
|
+
funnel?: "awareness" | "traffic" | "conversion" | null;
|
|
1947
|
+
priority?: number;
|
|
1948
|
+
enabled?: boolean;
|
|
1949
|
+
};
|
|
1950
|
+
headers?: {
|
|
1951
|
+
"Idempotency-Key"?: string;
|
|
1952
|
+
};
|
|
1953
|
+
path?: never;
|
|
1954
|
+
query?: never;
|
|
1955
|
+
url: "/v1/products/ad-rules";
|
|
1956
|
+
};
|
|
1957
|
+
export type ProductsSaveAdRuleCreateAdRuleErrors = {
|
|
1958
|
+
/**
|
|
1959
|
+
* api.invalid_json
|
|
1960
|
+
*/
|
|
1961
|
+
400: ErrorEnvelope;
|
|
1962
|
+
/**
|
|
1963
|
+
* api.invalid_key
|
|
1964
|
+
*/
|
|
1965
|
+
401: ErrorEnvelope;
|
|
1966
|
+
/**
|
|
1967
|
+
* api.insufficient_scope, api.forbidden
|
|
1968
|
+
*/
|
|
1969
|
+
403: ErrorEnvelope;
|
|
1970
|
+
/**
|
|
1971
|
+
* api.module_unavailable, products.not_found
|
|
1972
|
+
*/
|
|
1973
|
+
404: ErrorEnvelope;
|
|
1974
|
+
/**
|
|
1975
|
+
* api.idempotency_in_progress, products.archived
|
|
1976
|
+
*/
|
|
1977
|
+
409: ErrorEnvelope;
|
|
1978
|
+
/**
|
|
1979
|
+
* api.payload_too_large
|
|
1980
|
+
*/
|
|
1981
|
+
413: ErrorEnvelope;
|
|
1982
|
+
/**
|
|
1983
|
+
* api.unsupported_media_type
|
|
1984
|
+
*/
|
|
1985
|
+
415: ErrorEnvelope;
|
|
1986
|
+
/**
|
|
1987
|
+
* api.invalid_input, api.idempotency_key_reused, products.invalid_pattern
|
|
1988
|
+
*/
|
|
1989
|
+
422: ErrorEnvelope;
|
|
1990
|
+
/**
|
|
1991
|
+
* api.rate_limited
|
|
1992
|
+
*/
|
|
1993
|
+
429: ErrorEnvelope;
|
|
1994
|
+
/**
|
|
1995
|
+
* api.internal
|
|
1996
|
+
*/
|
|
1997
|
+
500: ErrorEnvelope;
|
|
1998
|
+
/**
|
|
1999
|
+
* api.workspace_preparing
|
|
2000
|
+
*/
|
|
2001
|
+
503: ErrorEnvelope;
|
|
2002
|
+
};
|
|
2003
|
+
export type ProductsSaveAdRuleCreateAdRuleError = ProductsSaveAdRuleCreateAdRuleErrors[keyof ProductsSaveAdRuleCreateAdRuleErrors];
|
|
2004
|
+
export type ProductsSaveAdRuleCreateAdRuleResponses = {
|
|
2005
|
+
/**
|
|
2006
|
+
* Success
|
|
2007
|
+
*/
|
|
2008
|
+
201: ProductsAddOfferResult;
|
|
2009
|
+
};
|
|
2010
|
+
export type ProductsSaveAdRuleCreateAdRuleResponse = ProductsSaveAdRuleCreateAdRuleResponses[keyof ProductsSaveAdRuleCreateAdRuleResponses];
|
|
2011
|
+
export type ProductsMatchAdData = {
|
|
2012
|
+
body?: never;
|
|
2013
|
+
path?: never;
|
|
2014
|
+
query: {
|
|
2015
|
+
name: string;
|
|
2016
|
+
};
|
|
2017
|
+
url: "/v1/products/ad-rules/match";
|
|
2018
|
+
};
|
|
2019
|
+
export type ProductsMatchAdErrors = {
|
|
2020
|
+
/**
|
|
2021
|
+
* api.invalid_key
|
|
2022
|
+
*/
|
|
2023
|
+
401: ErrorEnvelope;
|
|
2024
|
+
/**
|
|
2025
|
+
* api.insufficient_scope, api.forbidden
|
|
2026
|
+
*/
|
|
2027
|
+
403: ErrorEnvelope;
|
|
2028
|
+
/**
|
|
2029
|
+
* api.module_unavailable
|
|
2030
|
+
*/
|
|
2031
|
+
404: ErrorEnvelope;
|
|
2032
|
+
/**
|
|
2033
|
+
* api.invalid_input
|
|
2034
|
+
*/
|
|
2035
|
+
422: ErrorEnvelope;
|
|
2036
|
+
/**
|
|
2037
|
+
* api.rate_limited
|
|
2038
|
+
*/
|
|
2039
|
+
429: ErrorEnvelope;
|
|
2040
|
+
/**
|
|
2041
|
+
* api.internal
|
|
2042
|
+
*/
|
|
2043
|
+
500: ErrorEnvelope;
|
|
2044
|
+
/**
|
|
2045
|
+
* api.workspace_preparing
|
|
2046
|
+
*/
|
|
2047
|
+
503: ErrorEnvelope;
|
|
2048
|
+
};
|
|
2049
|
+
export type ProductsMatchAdError = ProductsMatchAdErrors[keyof ProductsMatchAdErrors];
|
|
2050
|
+
export type ProductsMatchAdResponses = {
|
|
2051
|
+
/**
|
|
2052
|
+
* Success
|
|
2053
|
+
*/
|
|
2054
|
+
200: ProductsMatchAdResult;
|
|
2055
|
+
};
|
|
2056
|
+
export type ProductsMatchAdResponse = ProductsMatchAdResponses[keyof ProductsMatchAdResponses];
|
|
2057
|
+
export type ProductsRemoveAdRuleData = {
|
|
2058
|
+
body?: {
|
|
2059
|
+
[key: string]: never;
|
|
2060
|
+
};
|
|
2061
|
+
headers?: {
|
|
2062
|
+
"Idempotency-Key"?: string;
|
|
2063
|
+
};
|
|
2064
|
+
path: {
|
|
2065
|
+
ruleId: string;
|
|
2066
|
+
};
|
|
2067
|
+
query?: never;
|
|
2068
|
+
url: "/v1/products/ad-rules/{ruleId}";
|
|
2069
|
+
};
|
|
2070
|
+
export type ProductsRemoveAdRuleErrors = {
|
|
2071
|
+
/**
|
|
2072
|
+
* api.invalid_json
|
|
2073
|
+
*/
|
|
2074
|
+
400: ErrorEnvelope;
|
|
2075
|
+
/**
|
|
2076
|
+
* api.invalid_key
|
|
2077
|
+
*/
|
|
2078
|
+
401: ErrorEnvelope;
|
|
2079
|
+
/**
|
|
2080
|
+
* api.insufficient_scope, api.forbidden
|
|
2081
|
+
*/
|
|
2082
|
+
403: ErrorEnvelope;
|
|
2083
|
+
/**
|
|
2084
|
+
* api.module_unavailable, products.not_found
|
|
2085
|
+
*/
|
|
2086
|
+
404: ErrorEnvelope;
|
|
2087
|
+
/**
|
|
2088
|
+
* api.idempotency_in_progress
|
|
2089
|
+
*/
|
|
2090
|
+
409: ErrorEnvelope;
|
|
2091
|
+
/**
|
|
2092
|
+
* api.payload_too_large
|
|
2093
|
+
*/
|
|
2094
|
+
413: ErrorEnvelope;
|
|
2095
|
+
/**
|
|
2096
|
+
* api.unsupported_media_type
|
|
2097
|
+
*/
|
|
2098
|
+
415: ErrorEnvelope;
|
|
2099
|
+
/**
|
|
2100
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
2101
|
+
*/
|
|
2102
|
+
422: ErrorEnvelope;
|
|
2103
|
+
/**
|
|
2104
|
+
* api.rate_limited
|
|
2105
|
+
*/
|
|
2106
|
+
429: ErrorEnvelope;
|
|
2107
|
+
/**
|
|
2108
|
+
* api.internal
|
|
2109
|
+
*/
|
|
2110
|
+
500: ErrorEnvelope;
|
|
2111
|
+
/**
|
|
2112
|
+
* api.workspace_preparing
|
|
2113
|
+
*/
|
|
2114
|
+
503: ErrorEnvelope;
|
|
2115
|
+
};
|
|
2116
|
+
export type ProductsRemoveAdRuleError = ProductsRemoveAdRuleErrors[keyof ProductsRemoveAdRuleErrors];
|
|
2117
|
+
export type ProductsRemoveAdRuleResponses = {
|
|
2118
|
+
/**
|
|
2119
|
+
* Success
|
|
2120
|
+
*/
|
|
2121
|
+
200: ProductsAddOfferResult;
|
|
2122
|
+
};
|
|
2123
|
+
export type ProductsRemoveAdRuleResponse = ProductsRemoveAdRuleResponses[keyof ProductsRemoveAdRuleResponses];
|
|
2124
|
+
export type ProductsSaveAdRuleUpdateAdRuleData = {
|
|
2125
|
+
body: {
|
|
2126
|
+
productId: string;
|
|
2127
|
+
pattern: string;
|
|
2128
|
+
matchType: "contains" | "prefix" | "regex";
|
|
2129
|
+
funnel?: "awareness" | "traffic" | "conversion" | null;
|
|
2130
|
+
priority?: number;
|
|
2131
|
+
enabled?: boolean;
|
|
2132
|
+
};
|
|
2133
|
+
headers?: {
|
|
2134
|
+
"Idempotency-Key"?: string;
|
|
2135
|
+
};
|
|
2136
|
+
path: {
|
|
2137
|
+
ruleId: string;
|
|
2138
|
+
};
|
|
2139
|
+
query?: never;
|
|
2140
|
+
url: "/v1/products/ad-rules/{ruleId}";
|
|
2141
|
+
};
|
|
2142
|
+
export type ProductsSaveAdRuleUpdateAdRuleErrors = {
|
|
2143
|
+
/**
|
|
2144
|
+
* api.invalid_json
|
|
2145
|
+
*/
|
|
2146
|
+
400: ErrorEnvelope;
|
|
2147
|
+
/**
|
|
2148
|
+
* api.invalid_key
|
|
2149
|
+
*/
|
|
2150
|
+
401: ErrorEnvelope;
|
|
2151
|
+
/**
|
|
2152
|
+
* api.insufficient_scope, api.forbidden
|
|
2153
|
+
*/
|
|
2154
|
+
403: ErrorEnvelope;
|
|
2155
|
+
/**
|
|
2156
|
+
* api.module_unavailable, products.not_found
|
|
2157
|
+
*/
|
|
2158
|
+
404: ErrorEnvelope;
|
|
2159
|
+
/**
|
|
2160
|
+
* api.idempotency_in_progress, products.archived
|
|
2161
|
+
*/
|
|
2162
|
+
409: ErrorEnvelope;
|
|
2163
|
+
/**
|
|
2164
|
+
* api.payload_too_large
|
|
2165
|
+
*/
|
|
2166
|
+
413: ErrorEnvelope;
|
|
2167
|
+
/**
|
|
2168
|
+
* api.unsupported_media_type
|
|
2169
|
+
*/
|
|
2170
|
+
415: ErrorEnvelope;
|
|
2171
|
+
/**
|
|
2172
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused, products.invalid_pattern
|
|
2173
|
+
*/
|
|
2174
|
+
422: ErrorEnvelope;
|
|
2175
|
+
/**
|
|
2176
|
+
* api.rate_limited
|
|
2177
|
+
*/
|
|
2178
|
+
429: ErrorEnvelope;
|
|
2179
|
+
/**
|
|
2180
|
+
* api.internal
|
|
2181
|
+
*/
|
|
2182
|
+
500: ErrorEnvelope;
|
|
2183
|
+
/**
|
|
2184
|
+
* api.workspace_preparing
|
|
2185
|
+
*/
|
|
2186
|
+
503: ErrorEnvelope;
|
|
2187
|
+
};
|
|
2188
|
+
export type ProductsSaveAdRuleUpdateAdRuleError = ProductsSaveAdRuleUpdateAdRuleErrors[keyof ProductsSaveAdRuleUpdateAdRuleErrors];
|
|
2189
|
+
export type ProductsSaveAdRuleUpdateAdRuleResponses = {
|
|
2190
|
+
/**
|
|
2191
|
+
* Success
|
|
2192
|
+
*/
|
|
2193
|
+
200: ProductsAddOfferResult;
|
|
2194
|
+
};
|
|
2195
|
+
export type ProductsSaveAdRuleUpdateAdRuleResponse = ProductsSaveAdRuleUpdateAdRuleResponses[keyof ProductsSaveAdRuleUpdateAdRuleResponses];
|
|
2196
|
+
export type ProductsRemoveOfferData = {
|
|
2197
|
+
body?: {
|
|
2198
|
+
[key: string]: never;
|
|
2199
|
+
};
|
|
2200
|
+
headers?: {
|
|
2201
|
+
"Idempotency-Key"?: string;
|
|
2202
|
+
};
|
|
2203
|
+
path: {
|
|
2204
|
+
offerId: string;
|
|
2205
|
+
};
|
|
2206
|
+
query?: never;
|
|
2207
|
+
url: "/v1/products/offers/{offerId}";
|
|
2208
|
+
};
|
|
2209
|
+
export type ProductsRemoveOfferErrors = {
|
|
2210
|
+
/**
|
|
2211
|
+
* api.invalid_json
|
|
2212
|
+
*/
|
|
2213
|
+
400: ErrorEnvelope;
|
|
2214
|
+
/**
|
|
2215
|
+
* api.invalid_key
|
|
2216
|
+
*/
|
|
2217
|
+
401: ErrorEnvelope;
|
|
2218
|
+
/**
|
|
2219
|
+
* api.insufficient_scope, api.forbidden
|
|
2220
|
+
*/
|
|
2221
|
+
403: ErrorEnvelope;
|
|
2222
|
+
/**
|
|
2223
|
+
* api.module_unavailable, products.not_found
|
|
2224
|
+
*/
|
|
2225
|
+
404: ErrorEnvelope;
|
|
2226
|
+
/**
|
|
2227
|
+
* api.idempotency_in_progress
|
|
2228
|
+
*/
|
|
2229
|
+
409: ErrorEnvelope;
|
|
2230
|
+
/**
|
|
2231
|
+
* api.payload_too_large
|
|
2232
|
+
*/
|
|
2233
|
+
413: ErrorEnvelope;
|
|
2234
|
+
/**
|
|
2235
|
+
* api.unsupported_media_type
|
|
2236
|
+
*/
|
|
2237
|
+
415: ErrorEnvelope;
|
|
2238
|
+
/**
|
|
2239
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
2240
|
+
*/
|
|
2241
|
+
422: ErrorEnvelope;
|
|
2242
|
+
/**
|
|
2243
|
+
* api.rate_limited
|
|
2244
|
+
*/
|
|
2245
|
+
429: ErrorEnvelope;
|
|
2246
|
+
/**
|
|
2247
|
+
* api.internal
|
|
2248
|
+
*/
|
|
2249
|
+
500: ErrorEnvelope;
|
|
2250
|
+
/**
|
|
2251
|
+
* api.workspace_preparing
|
|
2252
|
+
*/
|
|
2253
|
+
503: ErrorEnvelope;
|
|
2254
|
+
};
|
|
2255
|
+
export type ProductsRemoveOfferError = ProductsRemoveOfferErrors[keyof ProductsRemoveOfferErrors];
|
|
2256
|
+
export type ProductsRemoveOfferResponses = {
|
|
2257
|
+
/**
|
|
2258
|
+
* Success
|
|
2259
|
+
*/
|
|
2260
|
+
200: ProductsAddOfferResult;
|
|
2261
|
+
};
|
|
2262
|
+
export type ProductsRemoveOfferResponse = ProductsRemoveOfferResponses[keyof ProductsRemoveOfferResponses];
|
|
2263
|
+
export type ProductsResolveData = {
|
|
2264
|
+
body?: never;
|
|
2265
|
+
path?: never;
|
|
2266
|
+
query: {
|
|
2267
|
+
values: Array<string>;
|
|
2268
|
+
source?: string;
|
|
2269
|
+
};
|
|
2270
|
+
url: "/v1/products/products/resolve";
|
|
2271
|
+
};
|
|
2272
|
+
export type ProductsResolveErrors = {
|
|
2273
|
+
/**
|
|
2274
|
+
* api.invalid_key
|
|
2275
|
+
*/
|
|
2276
|
+
401: ErrorEnvelope;
|
|
2277
|
+
/**
|
|
2278
|
+
* api.insufficient_scope, api.forbidden
|
|
2279
|
+
*/
|
|
2280
|
+
403: ErrorEnvelope;
|
|
2281
|
+
/**
|
|
2282
|
+
* api.module_unavailable
|
|
2283
|
+
*/
|
|
2284
|
+
404: ErrorEnvelope;
|
|
2285
|
+
/**
|
|
2286
|
+
* api.invalid_input
|
|
2287
|
+
*/
|
|
2288
|
+
422: ErrorEnvelope;
|
|
2289
|
+
/**
|
|
2290
|
+
* api.rate_limited
|
|
2291
|
+
*/
|
|
2292
|
+
429: ErrorEnvelope;
|
|
2293
|
+
/**
|
|
2294
|
+
* api.internal
|
|
2295
|
+
*/
|
|
2296
|
+
500: ErrorEnvelope;
|
|
2297
|
+
/**
|
|
2298
|
+
* api.workspace_preparing
|
|
2299
|
+
*/
|
|
2300
|
+
503: ErrorEnvelope;
|
|
2301
|
+
};
|
|
2302
|
+
export type ProductsResolveError = ProductsResolveErrors[keyof ProductsResolveErrors];
|
|
2303
|
+
export type ProductsResolveResponses = {
|
|
2304
|
+
/**
|
|
2305
|
+
* Success
|
|
2306
|
+
*/
|
|
2307
|
+
200: ProductsResolveResult;
|
|
2308
|
+
};
|
|
2309
|
+
export type ProductsResolveResponse = ProductsResolveResponses[keyof ProductsResolveResponses];
|
|
2310
|
+
export type ProductsRestoreData = {
|
|
2311
|
+
body: {
|
|
2312
|
+
version: number;
|
|
2313
|
+
};
|
|
2314
|
+
headers?: {
|
|
2315
|
+
"Idempotency-Key"?: string;
|
|
2316
|
+
};
|
|
2317
|
+
path: {
|
|
2318
|
+
productId: string;
|
|
2319
|
+
};
|
|
2320
|
+
query?: never;
|
|
2321
|
+
url: "/v1/products/products/{productId}/restore";
|
|
2322
|
+
};
|
|
2323
|
+
export type ProductsRestoreErrors = {
|
|
2324
|
+
/**
|
|
2325
|
+
* api.invalid_json
|
|
2326
|
+
*/
|
|
2327
|
+
400: ErrorEnvelope;
|
|
2328
|
+
/**
|
|
2329
|
+
* api.invalid_key
|
|
2330
|
+
*/
|
|
2331
|
+
401: ErrorEnvelope;
|
|
2332
|
+
/**
|
|
2333
|
+
* api.insufficient_scope, api.forbidden
|
|
2334
|
+
*/
|
|
2335
|
+
403: ErrorEnvelope;
|
|
2336
|
+
/**
|
|
2337
|
+
* api.module_unavailable, products.not_found
|
|
2338
|
+
*/
|
|
2339
|
+
404: ErrorEnvelope;
|
|
2340
|
+
/**
|
|
2341
|
+
* api.idempotency_in_progress, products.version_conflict
|
|
2342
|
+
*/
|
|
2343
|
+
409: ErrorEnvelope;
|
|
2344
|
+
/**
|
|
2345
|
+
* api.payload_too_large
|
|
2346
|
+
*/
|
|
2347
|
+
413: ErrorEnvelope;
|
|
2348
|
+
/**
|
|
2349
|
+
* api.unsupported_media_type
|
|
2350
|
+
*/
|
|
2351
|
+
415: ErrorEnvelope;
|
|
2352
|
+
/**
|
|
2353
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
2354
|
+
*/
|
|
2355
|
+
422: ErrorEnvelope;
|
|
2356
|
+
/**
|
|
2357
|
+
* api.rate_limited
|
|
2358
|
+
*/
|
|
2359
|
+
429: ErrorEnvelope;
|
|
2360
|
+
/**
|
|
2361
|
+
* api.internal
|
|
2362
|
+
*/
|
|
2363
|
+
500: ErrorEnvelope;
|
|
2364
|
+
/**
|
|
2365
|
+
* api.workspace_preparing
|
|
2366
|
+
*/
|
|
2367
|
+
503: ErrorEnvelope;
|
|
2368
|
+
};
|
|
2369
|
+
export type ProductsRestoreError = ProductsRestoreErrors[keyof ProductsRestoreErrors];
|
|
2370
|
+
export type ProductsRestoreResponses = {
|
|
2371
|
+
/**
|
|
2372
|
+
* Success
|
|
2373
|
+
*/
|
|
2374
|
+
200: ProductsAddOfferResult;
|
|
2375
|
+
};
|
|
2376
|
+
export type ProductsRestoreResponse = ProductsRestoreResponses[keyof ProductsRestoreResponses];
|
|
2377
|
+
export type TasksCommentListData = {
|
|
2378
|
+
body?: never;
|
|
2379
|
+
path: {
|
|
2380
|
+
task: string;
|
|
2381
|
+
};
|
|
2382
|
+
query?: {
|
|
2383
|
+
/**
|
|
2384
|
+
* Opaque cursor returned by the previous page.
|
|
2385
|
+
*/
|
|
2386
|
+
cursor?: string;
|
|
2387
|
+
limit?: number;
|
|
2388
|
+
};
|
|
2389
|
+
url: "/v1/tasks/tasks/{task}/comments";
|
|
2390
|
+
};
|
|
2391
|
+
export type TasksCommentListErrors = {
|
|
2392
|
+
/**
|
|
2393
|
+
* api.invalid_key
|
|
2394
|
+
*/
|
|
2395
|
+
401: ErrorEnvelope;
|
|
2396
|
+
/**
|
|
2397
|
+
* api.insufficient_scope, api.forbidden
|
|
2398
|
+
*/
|
|
2399
|
+
403: ErrorEnvelope;
|
|
2400
|
+
/**
|
|
2401
|
+
* api.module_unavailable, tasks.not_found
|
|
2402
|
+
*/
|
|
2403
|
+
404: ErrorEnvelope;
|
|
2404
|
+
/**
|
|
2405
|
+
* api.invalid_input, tasks.validation
|
|
2406
|
+
*/
|
|
2407
|
+
422: ErrorEnvelope;
|
|
2408
|
+
/**
|
|
2409
|
+
* api.rate_limited
|
|
2410
|
+
*/
|
|
2411
|
+
429: ErrorEnvelope;
|
|
2412
|
+
/**
|
|
2413
|
+
* api.internal
|
|
2414
|
+
*/
|
|
2415
|
+
500: ErrorEnvelope;
|
|
2416
|
+
/**
|
|
2417
|
+
* api.workspace_preparing
|
|
2418
|
+
*/
|
|
2419
|
+
503: ErrorEnvelope;
|
|
2420
|
+
};
|
|
2421
|
+
export type TasksCommentListError = TasksCommentListErrors[keyof TasksCommentListErrors];
|
|
2422
|
+
export type TasksCommentListResponses = {
|
|
2423
|
+
/**
|
|
2424
|
+
* Success
|
|
2425
|
+
*/
|
|
2426
|
+
200: TasksCommentListResult;
|
|
2427
|
+
};
|
|
2428
|
+
export type TasksCommentListResponse = TasksCommentListResponses[keyof TasksCommentListResponses];
|
|
2429
|
+
export type TasksCommentAddData = {
|
|
2430
|
+
body: {
|
|
2431
|
+
body: string;
|
|
2432
|
+
};
|
|
2433
|
+
headers?: {
|
|
2434
|
+
"Idempotency-Key"?: string;
|
|
2435
|
+
};
|
|
2436
|
+
path: {
|
|
2437
|
+
task: string;
|
|
2438
|
+
};
|
|
2439
|
+
query?: never;
|
|
2440
|
+
url: "/v1/tasks/tasks/{task}/comments";
|
|
2441
|
+
};
|
|
2442
|
+
export type TasksCommentAddErrors = {
|
|
2443
|
+
/**
|
|
2444
|
+
* api.invalid_json
|
|
2445
|
+
*/
|
|
2446
|
+
400: ErrorEnvelope;
|
|
2447
|
+
/**
|
|
2448
|
+
* api.invalid_key
|
|
2449
|
+
*/
|
|
2450
|
+
401: ErrorEnvelope;
|
|
2451
|
+
/**
|
|
2452
|
+
* api.insufficient_scope, api.forbidden
|
|
2453
|
+
*/
|
|
2454
|
+
403: ErrorEnvelope;
|
|
2455
|
+
/**
|
|
2456
|
+
* api.module_unavailable, tasks.not_found
|
|
2457
|
+
*/
|
|
2458
|
+
404: ErrorEnvelope;
|
|
2459
|
+
/**
|
|
2460
|
+
* tasks.archived, tasks.conflict
|
|
2461
|
+
*/
|
|
2462
|
+
409: ErrorEnvelope;
|
|
2463
|
+
/**
|
|
2464
|
+
* api.payload_too_large
|
|
2465
|
+
*/
|
|
2466
|
+
413: ErrorEnvelope;
|
|
2467
|
+
/**
|
|
2468
|
+
* api.unsupported_media_type
|
|
2469
|
+
*/
|
|
2470
|
+
415: ErrorEnvelope;
|
|
2471
|
+
/**
|
|
2472
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused, tasks.validation
|
|
2473
|
+
*/
|
|
2474
|
+
422: ErrorEnvelope;
|
|
2475
|
+
/**
|
|
2476
|
+
* api.rate_limited
|
|
2477
|
+
*/
|
|
2478
|
+
429: ErrorEnvelope;
|
|
2479
|
+
/**
|
|
2480
|
+
* api.internal
|
|
2481
|
+
*/
|
|
2482
|
+
500: ErrorEnvelope;
|
|
2483
|
+
/**
|
|
2484
|
+
* api.workspace_preparing
|
|
2485
|
+
*/
|
|
2486
|
+
503: ErrorEnvelope;
|
|
2487
|
+
};
|
|
2488
|
+
export type TasksCommentAddError = TasksCommentAddErrors[keyof TasksCommentAddErrors];
|
|
2489
|
+
export type TasksCommentAddResponses = {
|
|
2490
|
+
/**
|
|
2491
|
+
* Success
|
|
2492
|
+
*/
|
|
2493
|
+
201: TasksCommentAddResult;
|
|
2494
|
+
};
|
|
2495
|
+
export type TasksCommentAddResponse = TasksCommentAddResponses[keyof TasksCommentAddResponses];
|
|
2496
|
+
export type TasksTaskArchiveData = {
|
|
2497
|
+
body?: {
|
|
2498
|
+
[key: string]: never;
|
|
2499
|
+
};
|
|
2500
|
+
headers?: {
|
|
2501
|
+
"Idempotency-Key"?: string;
|
|
2502
|
+
};
|
|
2503
|
+
path: {
|
|
2504
|
+
task: string;
|
|
2505
|
+
};
|
|
2506
|
+
query?: never;
|
|
2507
|
+
url: "/v1/tasks/tasks/{task}/archive";
|
|
2508
|
+
};
|
|
2509
|
+
export type TasksTaskArchiveErrors = {
|
|
2510
|
+
/**
|
|
2511
|
+
* api.invalid_json
|
|
2512
|
+
*/
|
|
2513
|
+
400: ErrorEnvelope;
|
|
2514
|
+
/**
|
|
2515
|
+
* api.invalid_key
|
|
2516
|
+
*/
|
|
2517
|
+
401: ErrorEnvelope;
|
|
2518
|
+
/**
|
|
2519
|
+
* api.insufficient_scope, api.forbidden
|
|
2520
|
+
*/
|
|
2521
|
+
403: ErrorEnvelope;
|
|
2522
|
+
/**
|
|
2523
|
+
* api.module_unavailable, tasks.not_found
|
|
2524
|
+
*/
|
|
2525
|
+
404: ErrorEnvelope;
|
|
2526
|
+
/**
|
|
2527
|
+
* tasks.conflict, tasks.archived
|
|
2528
|
+
*/
|
|
2529
|
+
409: ErrorEnvelope;
|
|
2530
|
+
/**
|
|
2531
|
+
* api.payload_too_large
|
|
2532
|
+
*/
|
|
2533
|
+
413: ErrorEnvelope;
|
|
2534
|
+
/**
|
|
2535
|
+
* api.unsupported_media_type
|
|
2536
|
+
*/
|
|
2537
|
+
415: ErrorEnvelope;
|
|
2538
|
+
/**
|
|
2539
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
2540
|
+
*/
|
|
2541
|
+
422: ErrorEnvelope;
|
|
2542
|
+
/**
|
|
2543
|
+
* api.rate_limited
|
|
2544
|
+
*/
|
|
2545
|
+
429: ErrorEnvelope;
|
|
2546
|
+
/**
|
|
2547
|
+
* api.internal
|
|
2548
|
+
*/
|
|
2549
|
+
500: ErrorEnvelope;
|
|
2550
|
+
/**
|
|
2551
|
+
* api.workspace_preparing
|
|
2552
|
+
*/
|
|
2553
|
+
503: ErrorEnvelope;
|
|
2554
|
+
};
|
|
2555
|
+
export type TasksTaskArchiveError = TasksTaskArchiveErrors[keyof TasksTaskArchiveErrors];
|
|
2556
|
+
export type TasksTaskArchiveResponses = {
|
|
2557
|
+
/**
|
|
2558
|
+
* Success
|
|
2559
|
+
*/
|
|
2560
|
+
200: TasksTaskArchiveResult;
|
|
2561
|
+
};
|
|
2562
|
+
export type TasksTaskArchiveResponse = TasksTaskArchiveResponses[keyof TasksTaskArchiveResponses];
|
|
2563
|
+
export type TasksTaskArchiveRestoreData = {
|
|
2564
|
+
body?: {
|
|
2565
|
+
[key: string]: never;
|
|
2566
|
+
};
|
|
2567
|
+
headers?: {
|
|
2568
|
+
"Idempotency-Key"?: string;
|
|
2569
|
+
};
|
|
2570
|
+
path: {
|
|
2571
|
+
task: string;
|
|
2572
|
+
};
|
|
2573
|
+
query?: never;
|
|
2574
|
+
url: "/v1/tasks/tasks/{task}/restore";
|
|
2575
|
+
};
|
|
2576
|
+
export type TasksTaskArchiveRestoreErrors = {
|
|
2577
|
+
/**
|
|
2578
|
+
* api.invalid_json
|
|
2579
|
+
*/
|
|
2580
|
+
400: ErrorEnvelope;
|
|
2581
|
+
/**
|
|
2582
|
+
* api.invalid_key
|
|
2583
|
+
*/
|
|
2584
|
+
401: ErrorEnvelope;
|
|
2585
|
+
/**
|
|
2586
|
+
* api.insufficient_scope, api.forbidden
|
|
2587
|
+
*/
|
|
2588
|
+
403: ErrorEnvelope;
|
|
2589
|
+
/**
|
|
2590
|
+
* api.module_unavailable, tasks.not_found
|
|
2591
|
+
*/
|
|
2592
|
+
404: ErrorEnvelope;
|
|
2593
|
+
/**
|
|
2594
|
+
* tasks.conflict, tasks.archived
|
|
2595
|
+
*/
|
|
2596
|
+
409: ErrorEnvelope;
|
|
2597
|
+
/**
|
|
2598
|
+
* api.payload_too_large
|
|
2599
|
+
*/
|
|
2600
|
+
413: ErrorEnvelope;
|
|
2601
|
+
/**
|
|
2602
|
+
* api.unsupported_media_type
|
|
2603
|
+
*/
|
|
2604
|
+
415: ErrorEnvelope;
|
|
2605
|
+
/**
|
|
2606
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused
|
|
2607
|
+
*/
|
|
2608
|
+
422: ErrorEnvelope;
|
|
2609
|
+
/**
|
|
2610
|
+
* api.rate_limited
|
|
2611
|
+
*/
|
|
2612
|
+
429: ErrorEnvelope;
|
|
2613
|
+
/**
|
|
2614
|
+
* api.internal
|
|
2615
|
+
*/
|
|
2616
|
+
500: ErrorEnvelope;
|
|
2617
|
+
/**
|
|
2618
|
+
* api.workspace_preparing
|
|
2619
|
+
*/
|
|
2620
|
+
503: ErrorEnvelope;
|
|
2621
|
+
};
|
|
2622
|
+
export type TasksTaskArchiveRestoreError = TasksTaskArchiveRestoreErrors[keyof TasksTaskArchiveRestoreErrors];
|
|
2623
|
+
export type TasksTaskArchiveRestoreResponses = {
|
|
2624
|
+
/**
|
|
2625
|
+
* Success
|
|
2626
|
+
*/
|
|
2627
|
+
200: TasksTaskArchiveResult;
|
|
2628
|
+
};
|
|
2629
|
+
export type TasksTaskArchiveRestoreResponse = TasksTaskArchiveRestoreResponses[keyof TasksTaskArchiveRestoreResponses];
|
|
2630
|
+
export type TasksTaskListData = {
|
|
2631
|
+
body?: never;
|
|
2632
|
+
path?: never;
|
|
2633
|
+
query?: {
|
|
2634
|
+
team?: string;
|
|
2635
|
+
status?: string;
|
|
2636
|
+
statuses?: Array<string>;
|
|
2637
|
+
category?: "backlog" | "unstarted" | "started" | "completed" | "canceled";
|
|
2638
|
+
statusCategory?: "backlog" | "unstarted" | "started" | "completed" | "canceled";
|
|
2639
|
+
assignee?: string;
|
|
2640
|
+
assignees?: Array<string>;
|
|
2641
|
+
priority?: 0 | 1 | 2 | 3 | 4;
|
|
2642
|
+
priorities?: Array<0 | 1 | 2 | 3 | 4>;
|
|
2643
|
+
label?: string;
|
|
2644
|
+
columnLabel?: string;
|
|
2645
|
+
labelGroup?: string;
|
|
2646
|
+
project?: string;
|
|
2647
|
+
milestone?: string;
|
|
2648
|
+
due?: "overdue" | "today" | "week" | "none" | "any" | Array<"overdue" | "today" | "week" | "none" | "any">;
|
|
2649
|
+
dueWithinDays?: number;
|
|
2650
|
+
dueFrom?: string;
|
|
2651
|
+
dueTo?: string;
|
|
2652
|
+
open?: boolean;
|
|
2653
|
+
query?: string;
|
|
2654
|
+
/**
|
|
2655
|
+
* Use 'none' for root tasks, or supply a parent task reference.
|
|
2656
|
+
*/
|
|
2657
|
+
parent?: string;
|
|
2658
|
+
archived?: boolean;
|
|
2659
|
+
order?: "manual" | "priority" | "dueDate" | "createdAt" | "updatedAt" | "milestone";
|
|
2660
|
+
orderBy?: "manual" | "priority" | "dueDate" | "createdAt" | "updatedAt" | "milestone";
|
|
2661
|
+
direction?: "asc" | "desc";
|
|
2662
|
+
/**
|
|
2663
|
+
* Opaque cursor returned by the previous page.
|
|
2664
|
+
*/
|
|
2665
|
+
cursor?: string;
|
|
2666
|
+
limit?: number;
|
|
2667
|
+
mine?: "assigned" | "created" | "following";
|
|
2668
|
+
};
|
|
2669
|
+
url: "/v1/tasks/tasks";
|
|
2670
|
+
};
|
|
2671
|
+
export type TasksTaskListErrors = {
|
|
2672
|
+
/**
|
|
2673
|
+
* api.invalid_key
|
|
2674
|
+
*/
|
|
2675
|
+
401: ErrorEnvelope;
|
|
2676
|
+
/**
|
|
2677
|
+
* api.insufficient_scope, api.forbidden
|
|
2678
|
+
*/
|
|
2679
|
+
403: ErrorEnvelope;
|
|
2680
|
+
/**
|
|
2681
|
+
* api.module_unavailable, tasks.not_found
|
|
2682
|
+
*/
|
|
2683
|
+
404: ErrorEnvelope;
|
|
2684
|
+
/**
|
|
2685
|
+
* api.invalid_input, tasks.validation
|
|
2686
|
+
*/
|
|
2687
|
+
422: ErrorEnvelope;
|
|
2688
|
+
/**
|
|
2689
|
+
* api.rate_limited
|
|
2690
|
+
*/
|
|
2691
|
+
429: ErrorEnvelope;
|
|
2692
|
+
/**
|
|
2693
|
+
* api.internal
|
|
2694
|
+
*/
|
|
2695
|
+
500: ErrorEnvelope;
|
|
2696
|
+
/**
|
|
2697
|
+
* api.workspace_preparing
|
|
2698
|
+
*/
|
|
2699
|
+
503: ErrorEnvelope;
|
|
2700
|
+
};
|
|
2701
|
+
export type TasksTaskListError = TasksTaskListErrors[keyof TasksTaskListErrors];
|
|
2702
|
+
export type TasksTaskListResponses = {
|
|
2703
|
+
/**
|
|
2704
|
+
* Success
|
|
2705
|
+
*/
|
|
2706
|
+
200: TasksTaskListResult;
|
|
2707
|
+
};
|
|
2708
|
+
export type TasksTaskListResponse = TasksTaskListResponses[keyof TasksTaskListResponses];
|
|
2709
|
+
export type TasksTaskCreateData = {
|
|
2710
|
+
body: {
|
|
2711
|
+
team: string;
|
|
2712
|
+
title: string;
|
|
2713
|
+
status?: string;
|
|
2714
|
+
priority?: number;
|
|
2715
|
+
assignee?: string | null;
|
|
2716
|
+
dueDate?: string | null;
|
|
2717
|
+
parent?: string | null;
|
|
2718
|
+
labels?: Array<string>;
|
|
2719
|
+
project?: string | null;
|
|
2720
|
+
milestone?: string | null;
|
|
2721
|
+
description?: string;
|
|
2722
|
+
recurrence?: {
|
|
2723
|
+
mode: "schedule" | "completion";
|
|
2724
|
+
rule: {
|
|
2725
|
+
freq: "daily";
|
|
2726
|
+
interval: number;
|
|
2727
|
+
end: {
|
|
2728
|
+
kind: "never";
|
|
2729
|
+
} | {
|
|
2730
|
+
kind: "until";
|
|
2731
|
+
date: string;
|
|
2732
|
+
} | {
|
|
2733
|
+
kind: "count";
|
|
2734
|
+
count: number;
|
|
2735
|
+
};
|
|
2736
|
+
} | {
|
|
2737
|
+
freq: "weekly";
|
|
2738
|
+
interval: number;
|
|
2739
|
+
end: {
|
|
2740
|
+
kind: "never";
|
|
2741
|
+
} | {
|
|
2742
|
+
kind: "until";
|
|
2743
|
+
date: string;
|
|
2744
|
+
} | {
|
|
2745
|
+
kind: "count";
|
|
2746
|
+
count: number;
|
|
2747
|
+
};
|
|
2748
|
+
weekdays: Array<1 | 2 | 3 | 4 | 5 | 6 | 7>;
|
|
2749
|
+
} | {
|
|
2750
|
+
freq: "monthly";
|
|
2751
|
+
interval: number;
|
|
2752
|
+
end: {
|
|
2753
|
+
kind: "never";
|
|
2754
|
+
} | {
|
|
2755
|
+
kind: "until";
|
|
2756
|
+
date: string;
|
|
2757
|
+
} | {
|
|
2758
|
+
kind: "count";
|
|
2759
|
+
count: number;
|
|
2760
|
+
};
|
|
2761
|
+
monthDay: "last" | number;
|
|
2762
|
+
} | {
|
|
2763
|
+
freq: "yearly";
|
|
2764
|
+
interval: number;
|
|
2765
|
+
end: {
|
|
2766
|
+
kind: "never";
|
|
2767
|
+
} | {
|
|
2768
|
+
kind: "until";
|
|
2769
|
+
date: string;
|
|
2770
|
+
} | {
|
|
2771
|
+
kind: "count";
|
|
2772
|
+
count: number;
|
|
2773
|
+
};
|
|
2774
|
+
month: number;
|
|
2775
|
+
day: number;
|
|
2776
|
+
};
|
|
2777
|
+
};
|
|
2778
|
+
};
|
|
2779
|
+
headers?: {
|
|
2780
|
+
"Idempotency-Key"?: string;
|
|
2781
|
+
};
|
|
2782
|
+
path?: never;
|
|
2783
|
+
query?: never;
|
|
2784
|
+
url: "/v1/tasks/tasks";
|
|
2785
|
+
};
|
|
2786
|
+
export type TasksTaskCreateErrors = {
|
|
2787
|
+
/**
|
|
2788
|
+
* api.invalid_json
|
|
2789
|
+
*/
|
|
2790
|
+
400: ErrorEnvelope;
|
|
2791
|
+
/**
|
|
2792
|
+
* api.invalid_key
|
|
2793
|
+
*/
|
|
2794
|
+
401: ErrorEnvelope;
|
|
2795
|
+
/**
|
|
2796
|
+
* api.insufficient_scope, api.forbidden
|
|
2797
|
+
*/
|
|
2798
|
+
403: ErrorEnvelope;
|
|
2799
|
+
/**
|
|
2800
|
+
* api.module_unavailable, tasks.not_found
|
|
2801
|
+
*/
|
|
2802
|
+
404: ErrorEnvelope;
|
|
2803
|
+
/**
|
|
2804
|
+
* tasks.conflict, tasks.archived
|
|
2805
|
+
*/
|
|
2806
|
+
409: ErrorEnvelope;
|
|
2807
|
+
/**
|
|
2808
|
+
* api.payload_too_large
|
|
2809
|
+
*/
|
|
2810
|
+
413: ErrorEnvelope;
|
|
2811
|
+
/**
|
|
2812
|
+
* api.unsupported_media_type
|
|
2813
|
+
*/
|
|
2814
|
+
415: ErrorEnvelope;
|
|
2815
|
+
/**
|
|
2816
|
+
* api.invalid_input, api.idempotency_key_reused, tasks.validation, tasks.limit
|
|
2817
|
+
*/
|
|
2818
|
+
422: ErrorEnvelope;
|
|
2819
|
+
/**
|
|
2820
|
+
* api.rate_limited
|
|
2821
|
+
*/
|
|
2822
|
+
429: ErrorEnvelope;
|
|
2823
|
+
/**
|
|
2824
|
+
* api.internal
|
|
2825
|
+
*/
|
|
2826
|
+
500: ErrorEnvelope;
|
|
2827
|
+
/**
|
|
2828
|
+
* api.workspace_preparing
|
|
2829
|
+
*/
|
|
2830
|
+
503: ErrorEnvelope;
|
|
2831
|
+
};
|
|
2832
|
+
export type TasksTaskCreateError = TasksTaskCreateErrors[keyof TasksTaskCreateErrors];
|
|
2833
|
+
export type TasksTaskCreateResponses = {
|
|
2834
|
+
/**
|
|
2835
|
+
* Success
|
|
2836
|
+
*/
|
|
2837
|
+
201: TasksTaskArchiveResult;
|
|
2838
|
+
};
|
|
2839
|
+
export type TasksTaskCreateResponse = TasksTaskCreateResponses[keyof TasksTaskCreateResponses];
|
|
2840
|
+
export type TasksTaskGetData = {
|
|
2841
|
+
body?: never;
|
|
2842
|
+
path: {
|
|
2843
|
+
task: string;
|
|
2844
|
+
};
|
|
2845
|
+
query?: never;
|
|
2846
|
+
url: "/v1/tasks/tasks/{task}";
|
|
2847
|
+
};
|
|
2848
|
+
export type TasksTaskGetErrors = {
|
|
2849
|
+
/**
|
|
2850
|
+
* api.invalid_key
|
|
2851
|
+
*/
|
|
2852
|
+
401: ErrorEnvelope;
|
|
2853
|
+
/**
|
|
2854
|
+
* api.insufficient_scope, api.forbidden
|
|
2855
|
+
*/
|
|
2856
|
+
403: ErrorEnvelope;
|
|
2857
|
+
/**
|
|
2858
|
+
* api.module_unavailable, tasks.not_found
|
|
2859
|
+
*/
|
|
2860
|
+
404: ErrorEnvelope;
|
|
2861
|
+
/**
|
|
2862
|
+
* api.invalid_input
|
|
2863
|
+
*/
|
|
2864
|
+
422: ErrorEnvelope;
|
|
2865
|
+
/**
|
|
2866
|
+
* api.rate_limited
|
|
2867
|
+
*/
|
|
2868
|
+
429: ErrorEnvelope;
|
|
2869
|
+
/**
|
|
2870
|
+
* api.internal
|
|
2871
|
+
*/
|
|
2872
|
+
500: ErrorEnvelope;
|
|
2873
|
+
/**
|
|
2874
|
+
* api.workspace_preparing
|
|
2875
|
+
*/
|
|
2876
|
+
503: ErrorEnvelope;
|
|
2877
|
+
};
|
|
2878
|
+
export type TasksTaskGetError = TasksTaskGetErrors[keyof TasksTaskGetErrors];
|
|
2879
|
+
export type TasksTaskGetResponses = {
|
|
2880
|
+
/**
|
|
2881
|
+
* Success
|
|
2882
|
+
*/
|
|
2883
|
+
200: TasksTaskArchiveResult;
|
|
2884
|
+
};
|
|
2885
|
+
export type TasksTaskGetResponse = TasksTaskGetResponses[keyof TasksTaskGetResponses];
|
|
2886
|
+
export type TasksTaskUpdateData = {
|
|
2887
|
+
body?: {
|
|
2888
|
+
addLabels?: Array<string>;
|
|
2889
|
+
recurrence?: {
|
|
2890
|
+
mode: "schedule" | "completion";
|
|
2891
|
+
rule: {
|
|
2892
|
+
freq: "daily";
|
|
2893
|
+
interval: number;
|
|
2894
|
+
end: {
|
|
2895
|
+
kind: "never";
|
|
2896
|
+
} | {
|
|
2897
|
+
kind: "until";
|
|
2898
|
+
date: string;
|
|
2899
|
+
} | {
|
|
2900
|
+
kind: "count";
|
|
2901
|
+
count: number;
|
|
2902
|
+
};
|
|
2903
|
+
} | {
|
|
2904
|
+
freq: "weekly";
|
|
2905
|
+
interval: number;
|
|
2906
|
+
end: {
|
|
2907
|
+
kind: "never";
|
|
2908
|
+
} | {
|
|
2909
|
+
kind: "until";
|
|
2910
|
+
date: string;
|
|
2911
|
+
} | {
|
|
2912
|
+
kind: "count";
|
|
2913
|
+
count: number;
|
|
2914
|
+
};
|
|
2915
|
+
weekdays: Array<1 | 2 | 3 | 4 | 5 | 6 | 7>;
|
|
2916
|
+
} | {
|
|
2917
|
+
freq: "monthly";
|
|
2918
|
+
interval: number;
|
|
2919
|
+
end: {
|
|
2920
|
+
kind: "never";
|
|
2921
|
+
} | {
|
|
2922
|
+
kind: "until";
|
|
2923
|
+
date: string;
|
|
2924
|
+
} | {
|
|
2925
|
+
kind: "count";
|
|
2926
|
+
count: number;
|
|
2927
|
+
};
|
|
2928
|
+
monthDay: "last" | number;
|
|
2929
|
+
} | {
|
|
2930
|
+
freq: "yearly";
|
|
2931
|
+
interval: number;
|
|
2932
|
+
end: {
|
|
2933
|
+
kind: "never";
|
|
2934
|
+
} | {
|
|
2935
|
+
kind: "until";
|
|
2936
|
+
date: string;
|
|
2937
|
+
} | {
|
|
2938
|
+
kind: "count";
|
|
2939
|
+
count: number;
|
|
2940
|
+
};
|
|
2941
|
+
month: number;
|
|
2942
|
+
day: number;
|
|
2943
|
+
};
|
|
2944
|
+
} | null;
|
|
2945
|
+
seriesScope?: "this" | "following";
|
|
2946
|
+
seriesRestore?: {
|
|
2947
|
+
id: string;
|
|
2948
|
+
rule: {
|
|
2949
|
+
freq: "daily";
|
|
2950
|
+
interval: number;
|
|
2951
|
+
end: {
|
|
2952
|
+
kind: "never";
|
|
2953
|
+
} | {
|
|
2954
|
+
kind: "until";
|
|
2955
|
+
date: string;
|
|
2956
|
+
} | {
|
|
2957
|
+
kind: "count";
|
|
2958
|
+
count: number;
|
|
2959
|
+
};
|
|
2960
|
+
} | {
|
|
2961
|
+
freq: "weekly";
|
|
2962
|
+
interval: number;
|
|
2963
|
+
end: {
|
|
2964
|
+
kind: "never";
|
|
2965
|
+
} | {
|
|
2966
|
+
kind: "until";
|
|
2967
|
+
date: string;
|
|
2968
|
+
} | {
|
|
2969
|
+
kind: "count";
|
|
2970
|
+
count: number;
|
|
2971
|
+
};
|
|
2972
|
+
weekdays: Array<1 | 2 | 3 | 4 | 5 | 6 | 7>;
|
|
2973
|
+
} | {
|
|
2974
|
+
freq: "monthly";
|
|
2975
|
+
interval: number;
|
|
2976
|
+
end: {
|
|
2977
|
+
kind: "never";
|
|
2978
|
+
} | {
|
|
2979
|
+
kind: "until";
|
|
2980
|
+
date: string;
|
|
2981
|
+
} | {
|
|
2982
|
+
kind: "count";
|
|
2983
|
+
count: number;
|
|
2984
|
+
};
|
|
2985
|
+
monthDay: "last" | number;
|
|
2986
|
+
} | {
|
|
2987
|
+
freq: "yearly";
|
|
2988
|
+
interval: number;
|
|
2989
|
+
end: {
|
|
2990
|
+
kind: "never";
|
|
2991
|
+
} | {
|
|
2992
|
+
kind: "until";
|
|
2993
|
+
date: string;
|
|
2994
|
+
} | {
|
|
2995
|
+
kind: "count";
|
|
2996
|
+
count: number;
|
|
2997
|
+
};
|
|
2998
|
+
month: number;
|
|
2999
|
+
day: number;
|
|
3000
|
+
};
|
|
3001
|
+
anchorDate: string;
|
|
3002
|
+
model?: {
|
|
3003
|
+
assignee?: string | null;
|
|
3004
|
+
priority?: number;
|
|
3005
|
+
projectId?: string | null;
|
|
3006
|
+
};
|
|
3007
|
+
};
|
|
3008
|
+
title?: string;
|
|
3009
|
+
status?: string;
|
|
3010
|
+
priority?: number;
|
|
3011
|
+
assignee?: string | null;
|
|
3012
|
+
dueDate?: string | null;
|
|
3013
|
+
parent?: string | null;
|
|
3014
|
+
labels?: Array<string>;
|
|
3015
|
+
project?: string | null;
|
|
3016
|
+
milestone?: string | null;
|
|
3017
|
+
description?: string;
|
|
3018
|
+
expectedDescriptionVersion?: number;
|
|
3019
|
+
before?: string | null;
|
|
3020
|
+
after?: string | null;
|
|
3021
|
+
};
|
|
3022
|
+
headers?: {
|
|
3023
|
+
"Idempotency-Key"?: string;
|
|
3024
|
+
};
|
|
3025
|
+
path: {
|
|
3026
|
+
task: string;
|
|
3027
|
+
};
|
|
3028
|
+
query?: never;
|
|
3029
|
+
url: "/v1/tasks/tasks/{task}";
|
|
3030
|
+
};
|
|
3031
|
+
export type TasksTaskUpdateErrors = {
|
|
3032
|
+
/**
|
|
3033
|
+
* api.invalid_json
|
|
3034
|
+
*/
|
|
3035
|
+
400: ErrorEnvelope;
|
|
3036
|
+
/**
|
|
3037
|
+
* api.invalid_key
|
|
3038
|
+
*/
|
|
3039
|
+
401: ErrorEnvelope;
|
|
3040
|
+
/**
|
|
3041
|
+
* api.insufficient_scope, api.forbidden
|
|
3042
|
+
*/
|
|
3043
|
+
403: ErrorEnvelope;
|
|
3044
|
+
/**
|
|
3045
|
+
* api.module_unavailable, tasks.not_found
|
|
3046
|
+
*/
|
|
3047
|
+
404: ErrorEnvelope;
|
|
3048
|
+
/**
|
|
3049
|
+
* tasks.conflict, tasks.archived
|
|
3050
|
+
*/
|
|
3051
|
+
409: ErrorEnvelope;
|
|
3052
|
+
/**
|
|
3053
|
+
* api.payload_too_large
|
|
3054
|
+
*/
|
|
3055
|
+
413: ErrorEnvelope;
|
|
3056
|
+
/**
|
|
3057
|
+
* api.unsupported_media_type
|
|
3058
|
+
*/
|
|
3059
|
+
415: ErrorEnvelope;
|
|
3060
|
+
/**
|
|
3061
|
+
* api.invalid_input, api.path_body_conflict, api.idempotency_key_reused, tasks.validation, tasks.limit
|
|
3062
|
+
*/
|
|
3063
|
+
422: ErrorEnvelope;
|
|
3064
|
+
/**
|
|
3065
|
+
* api.rate_limited
|
|
3066
|
+
*/
|
|
3067
|
+
429: ErrorEnvelope;
|
|
3068
|
+
/**
|
|
3069
|
+
* api.internal
|
|
3070
|
+
*/
|
|
3071
|
+
500: ErrorEnvelope;
|
|
3072
|
+
/**
|
|
3073
|
+
* api.workspace_preparing
|
|
3074
|
+
*/
|
|
3075
|
+
503: ErrorEnvelope;
|
|
3076
|
+
};
|
|
3077
|
+
export type TasksTaskUpdateError = TasksTaskUpdateErrors[keyof TasksTaskUpdateErrors];
|
|
3078
|
+
export type TasksTaskUpdateResponses = {
|
|
3079
|
+
/**
|
|
3080
|
+
* Success
|
|
3081
|
+
*/
|
|
3082
|
+
200: TasksTaskArchiveResult;
|
|
3083
|
+
};
|
|
3084
|
+
export type TasksTaskUpdateResponse = TasksTaskUpdateResponses[keyof TasksTaskUpdateResponses];
|
|
3085
|
+
export type TasksTeamListData = {
|
|
3086
|
+
body?: never;
|
|
3087
|
+
path?: never;
|
|
3088
|
+
query?: {
|
|
3089
|
+
includeArchived?: boolean;
|
|
3090
|
+
kind?: "team" | "personal";
|
|
3091
|
+
};
|
|
3092
|
+
url: "/v1/tasks/teams";
|
|
3093
|
+
};
|
|
3094
|
+
export type TasksTeamListErrors = {
|
|
3095
|
+
/**
|
|
3096
|
+
* api.invalid_key
|
|
3097
|
+
*/
|
|
3098
|
+
401: ErrorEnvelope;
|
|
3099
|
+
/**
|
|
3100
|
+
* api.insufficient_scope, api.forbidden
|
|
3101
|
+
*/
|
|
3102
|
+
403: ErrorEnvelope;
|
|
3103
|
+
/**
|
|
3104
|
+
* api.module_unavailable
|
|
3105
|
+
*/
|
|
3106
|
+
404: ErrorEnvelope;
|
|
3107
|
+
/**
|
|
3108
|
+
* api.invalid_input
|
|
3109
|
+
*/
|
|
3110
|
+
422: ErrorEnvelope;
|
|
3111
|
+
/**
|
|
3112
|
+
* api.rate_limited
|
|
3113
|
+
*/
|
|
3114
|
+
429: ErrorEnvelope;
|
|
3115
|
+
/**
|
|
3116
|
+
* api.internal
|
|
3117
|
+
*/
|
|
3118
|
+
500: ErrorEnvelope;
|
|
3119
|
+
/**
|
|
3120
|
+
* api.workspace_preparing
|
|
3121
|
+
*/
|
|
3122
|
+
503: ErrorEnvelope;
|
|
3123
|
+
};
|
|
3124
|
+
export type TasksTeamListError = TasksTeamListErrors[keyof TasksTeamListErrors];
|
|
3125
|
+
export type TasksTeamListResponses = {
|
|
3126
|
+
/**
|
|
3127
|
+
* Success
|
|
3128
|
+
*/
|
|
3129
|
+
200: TasksTeamListResult;
|
|
3130
|
+
};
|
|
3131
|
+
export type TasksTeamListResponse = TasksTeamListResponses[keyof TasksTeamListResponses];
|