@opengeni/contracts 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +2547 -0
- package/dist/index.js +1295 -0
- package/dist/index.js.map +1 -0
- package/package.json +39 -0
- package/src/index.ts +1481 -0
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,2547 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
|
|
3
|
+
declare const SessionStatus: z.ZodEnum<{
|
|
4
|
+
queued: "queued";
|
|
5
|
+
running: "running";
|
|
6
|
+
idle: "idle";
|
|
7
|
+
requires_action: "requires_action";
|
|
8
|
+
failed: "failed";
|
|
9
|
+
cancelled: "cancelled";
|
|
10
|
+
}>;
|
|
11
|
+
type SessionStatus = z.infer<typeof SessionStatus>;
|
|
12
|
+
declare const SandboxBackend: z.ZodEnum<{
|
|
13
|
+
docker: "docker";
|
|
14
|
+
modal: "modal";
|
|
15
|
+
local: "local";
|
|
16
|
+
none: "none";
|
|
17
|
+
}>;
|
|
18
|
+
type SandboxBackend = z.infer<typeof SandboxBackend>;
|
|
19
|
+
declare const ReasoningEffort: z.ZodEnum<{
|
|
20
|
+
none: "none";
|
|
21
|
+
minimal: "minimal";
|
|
22
|
+
low: "low";
|
|
23
|
+
medium: "medium";
|
|
24
|
+
high: "high";
|
|
25
|
+
xhigh: "xhigh";
|
|
26
|
+
}>;
|
|
27
|
+
type ReasoningEffort = z.infer<typeof ReasoningEffort>;
|
|
28
|
+
declare const ErrorCode: z.ZodEnum<{
|
|
29
|
+
unauthenticated: "unauthenticated";
|
|
30
|
+
forbidden: "forbidden";
|
|
31
|
+
not_found: "not_found";
|
|
32
|
+
validation_failed: "validation_failed";
|
|
33
|
+
conflict: "conflict";
|
|
34
|
+
idempotency_conflict: "idempotency_conflict";
|
|
35
|
+
limit_exceeded: "limit_exceeded";
|
|
36
|
+
provider_verification_failed: "provider_verification_failed";
|
|
37
|
+
upstream_unavailable: "upstream_unavailable";
|
|
38
|
+
internal_error: "internal_error";
|
|
39
|
+
}>;
|
|
40
|
+
type ErrorCode = z.infer<typeof ErrorCode>;
|
|
41
|
+
declare const ErrorEnvelope: z.ZodObject<{
|
|
42
|
+
error: z.ZodObject<{
|
|
43
|
+
code: z.ZodEnum<{
|
|
44
|
+
unauthenticated: "unauthenticated";
|
|
45
|
+
forbidden: "forbidden";
|
|
46
|
+
not_found: "not_found";
|
|
47
|
+
validation_failed: "validation_failed";
|
|
48
|
+
conflict: "conflict";
|
|
49
|
+
idempotency_conflict: "idempotency_conflict";
|
|
50
|
+
limit_exceeded: "limit_exceeded";
|
|
51
|
+
provider_verification_failed: "provider_verification_failed";
|
|
52
|
+
upstream_unavailable: "upstream_unavailable";
|
|
53
|
+
internal_error: "internal_error";
|
|
54
|
+
}>;
|
|
55
|
+
message: z.ZodString;
|
|
56
|
+
requestId: z.ZodOptional<z.ZodString>;
|
|
57
|
+
details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
58
|
+
}, z.core.$strip>;
|
|
59
|
+
}, z.core.$strip>;
|
|
60
|
+
type ErrorEnvelope = z.infer<typeof ErrorEnvelope>;
|
|
61
|
+
declare const PageInfo: z.ZodObject<{
|
|
62
|
+
limit: z.ZodNumber;
|
|
63
|
+
nextCursor: z.ZodNullable<z.ZodString>;
|
|
64
|
+
hasMore: z.ZodBoolean;
|
|
65
|
+
}, z.core.$strip>;
|
|
66
|
+
type PageInfo = z.infer<typeof PageInfo>;
|
|
67
|
+
declare function paginated<T extends z.ZodTypeAny>(item: T): z.ZodObject<{
|
|
68
|
+
data: z.ZodArray<T>;
|
|
69
|
+
page: z.ZodObject<{
|
|
70
|
+
limit: z.ZodNumber;
|
|
71
|
+
nextCursor: z.ZodNullable<z.ZodString>;
|
|
72
|
+
hasMore: z.ZodBoolean;
|
|
73
|
+
}, z.core.$strip>;
|
|
74
|
+
}, z.core.$strip>;
|
|
75
|
+
declare const Permission: z.ZodEnum<{
|
|
76
|
+
"account:read": "account:read";
|
|
77
|
+
"account:admin": "account:admin";
|
|
78
|
+
"members:manage": "members:manage";
|
|
79
|
+
"workspace:create": "workspace:create";
|
|
80
|
+
"billing:read": "billing:read";
|
|
81
|
+
"billing:manage": "billing:manage";
|
|
82
|
+
"workspace:read": "workspace:read";
|
|
83
|
+
"workspace:admin": "workspace:admin";
|
|
84
|
+
"sessions:create": "sessions:create";
|
|
85
|
+
"sessions:read": "sessions:read";
|
|
86
|
+
"sessions:control": "sessions:control";
|
|
87
|
+
"files:upload": "files:upload";
|
|
88
|
+
"files:read": "files:read";
|
|
89
|
+
"documents:manage": "documents:manage";
|
|
90
|
+
"documents:search": "documents:search";
|
|
91
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
92
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
93
|
+
"github:manage": "github:manage";
|
|
94
|
+
"github:use": "github:use";
|
|
95
|
+
"api_keys:manage": "api_keys:manage";
|
|
96
|
+
"environments:manage": "environments:manage";
|
|
97
|
+
"environments:use": "environments:use";
|
|
98
|
+
"goals:manage": "goals:manage";
|
|
99
|
+
}>;
|
|
100
|
+
type Permission = z.infer<typeof Permission>;
|
|
101
|
+
declare const ProductAccessMode: z.ZodEnum<{
|
|
102
|
+
local: "local";
|
|
103
|
+
configured: "configured";
|
|
104
|
+
managed: "managed";
|
|
105
|
+
}>;
|
|
106
|
+
type ProductAccessMode = z.infer<typeof ProductAccessMode>;
|
|
107
|
+
declare const BillingMode: z.ZodEnum<{
|
|
108
|
+
disabled: "disabled";
|
|
109
|
+
stripe: "stripe";
|
|
110
|
+
}>;
|
|
111
|
+
type BillingMode = z.infer<typeof BillingMode>;
|
|
112
|
+
declare const EntitlementsMode: z.ZodEnum<{
|
|
113
|
+
none: "none";
|
|
114
|
+
managed: "managed";
|
|
115
|
+
static: "static";
|
|
116
|
+
}>;
|
|
117
|
+
type EntitlementsMode = z.infer<typeof EntitlementsMode>;
|
|
118
|
+
declare const UsageLimitsMode: z.ZodEnum<{
|
|
119
|
+
none: "none";
|
|
120
|
+
managed: "managed";
|
|
121
|
+
static: "static";
|
|
122
|
+
}>;
|
|
123
|
+
type UsageLimitsMode = z.infer<typeof UsageLimitsMode>;
|
|
124
|
+
declare const AccountRole: z.ZodEnum<{
|
|
125
|
+
owner: "owner";
|
|
126
|
+
admin: "admin";
|
|
127
|
+
member: "member";
|
|
128
|
+
}>;
|
|
129
|
+
type AccountRole = z.infer<typeof AccountRole>;
|
|
130
|
+
declare const ManagedAccount: z.ZodObject<{
|
|
131
|
+
id: z.ZodString;
|
|
132
|
+
name: z.ZodString;
|
|
133
|
+
externalSource: z.ZodNullable<z.ZodString>;
|
|
134
|
+
externalId: z.ZodNullable<z.ZodString>;
|
|
135
|
+
createdAt: z.ZodString;
|
|
136
|
+
updatedAt: z.ZodString;
|
|
137
|
+
}, z.core.$strip>;
|
|
138
|
+
type ManagedAccount = z.infer<typeof ManagedAccount>;
|
|
139
|
+
declare const Workspace: z.ZodObject<{
|
|
140
|
+
id: z.ZodString;
|
|
141
|
+
accountId: z.ZodString;
|
|
142
|
+
name: z.ZodString;
|
|
143
|
+
slug: z.ZodNullable<z.ZodString>;
|
|
144
|
+
externalSource: z.ZodNullable<z.ZodString>;
|
|
145
|
+
externalId: z.ZodNullable<z.ZodString>;
|
|
146
|
+
agentInstructions: z.ZodNullable<z.ZodString>;
|
|
147
|
+
createdAt: z.ZodString;
|
|
148
|
+
updatedAt: z.ZodString;
|
|
149
|
+
}, z.core.$strip>;
|
|
150
|
+
type Workspace = z.infer<typeof Workspace>;
|
|
151
|
+
declare const AccountGrant: z.ZodObject<{
|
|
152
|
+
accountId: z.ZodString;
|
|
153
|
+
subjectId: z.ZodString;
|
|
154
|
+
subjectLabel: z.ZodOptional<z.ZodString>;
|
|
155
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
156
|
+
owner: "owner";
|
|
157
|
+
admin: "admin";
|
|
158
|
+
member: "member";
|
|
159
|
+
}>>;
|
|
160
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
161
|
+
"account:read": "account:read";
|
|
162
|
+
"account:admin": "account:admin";
|
|
163
|
+
"members:manage": "members:manage";
|
|
164
|
+
"workspace:create": "workspace:create";
|
|
165
|
+
"billing:read": "billing:read";
|
|
166
|
+
"billing:manage": "billing:manage";
|
|
167
|
+
"workspace:read": "workspace:read";
|
|
168
|
+
"workspace:admin": "workspace:admin";
|
|
169
|
+
"sessions:create": "sessions:create";
|
|
170
|
+
"sessions:read": "sessions:read";
|
|
171
|
+
"sessions:control": "sessions:control";
|
|
172
|
+
"files:upload": "files:upload";
|
|
173
|
+
"files:read": "files:read";
|
|
174
|
+
"documents:manage": "documents:manage";
|
|
175
|
+
"documents:search": "documents:search";
|
|
176
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
177
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
178
|
+
"github:manage": "github:manage";
|
|
179
|
+
"github:use": "github:use";
|
|
180
|
+
"api_keys:manage": "api_keys:manage";
|
|
181
|
+
"environments:manage": "environments:manage";
|
|
182
|
+
"environments:use": "environments:use";
|
|
183
|
+
"goals:manage": "goals:manage";
|
|
184
|
+
}>>;
|
|
185
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
186
|
+
}, z.core.$strip>;
|
|
187
|
+
type AccountGrant = z.infer<typeof AccountGrant>;
|
|
188
|
+
declare const AccessGrant: z.ZodObject<{
|
|
189
|
+
workspaceId: z.ZodString;
|
|
190
|
+
accountId: z.ZodString;
|
|
191
|
+
subjectId: z.ZodString;
|
|
192
|
+
subjectLabel: z.ZodOptional<z.ZodString>;
|
|
193
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
194
|
+
"account:read": "account:read";
|
|
195
|
+
"account:admin": "account:admin";
|
|
196
|
+
"members:manage": "members:manage";
|
|
197
|
+
"workspace:create": "workspace:create";
|
|
198
|
+
"billing:read": "billing:read";
|
|
199
|
+
"billing:manage": "billing:manage";
|
|
200
|
+
"workspace:read": "workspace:read";
|
|
201
|
+
"workspace:admin": "workspace:admin";
|
|
202
|
+
"sessions:create": "sessions:create";
|
|
203
|
+
"sessions:read": "sessions:read";
|
|
204
|
+
"sessions:control": "sessions:control";
|
|
205
|
+
"files:upload": "files:upload";
|
|
206
|
+
"files:read": "files:read";
|
|
207
|
+
"documents:manage": "documents:manage";
|
|
208
|
+
"documents:search": "documents:search";
|
|
209
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
210
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
211
|
+
"github:manage": "github:manage";
|
|
212
|
+
"github:use": "github:use";
|
|
213
|
+
"api_keys:manage": "api_keys:manage";
|
|
214
|
+
"environments:manage": "environments:manage";
|
|
215
|
+
"environments:use": "environments:use";
|
|
216
|
+
"goals:manage": "goals:manage";
|
|
217
|
+
}>>;
|
|
218
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
219
|
+
}, z.core.$strip>;
|
|
220
|
+
type AccessGrant = z.infer<typeof AccessGrant>;
|
|
221
|
+
declare const AccessContext: z.ZodObject<{
|
|
222
|
+
mode: z.ZodEnum<{
|
|
223
|
+
local: "local";
|
|
224
|
+
configured: "configured";
|
|
225
|
+
managed: "managed";
|
|
226
|
+
}>;
|
|
227
|
+
subjectId: z.ZodString;
|
|
228
|
+
subjectLabel: z.ZodOptional<z.ZodString>;
|
|
229
|
+
accountGrants: z.ZodArray<z.ZodObject<{
|
|
230
|
+
accountId: z.ZodString;
|
|
231
|
+
subjectId: z.ZodString;
|
|
232
|
+
subjectLabel: z.ZodOptional<z.ZodString>;
|
|
233
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
234
|
+
owner: "owner";
|
|
235
|
+
admin: "admin";
|
|
236
|
+
member: "member";
|
|
237
|
+
}>>;
|
|
238
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
239
|
+
"account:read": "account:read";
|
|
240
|
+
"account:admin": "account:admin";
|
|
241
|
+
"members:manage": "members:manage";
|
|
242
|
+
"workspace:create": "workspace:create";
|
|
243
|
+
"billing:read": "billing:read";
|
|
244
|
+
"billing:manage": "billing:manage";
|
|
245
|
+
"workspace:read": "workspace:read";
|
|
246
|
+
"workspace:admin": "workspace:admin";
|
|
247
|
+
"sessions:create": "sessions:create";
|
|
248
|
+
"sessions:read": "sessions:read";
|
|
249
|
+
"sessions:control": "sessions:control";
|
|
250
|
+
"files:upload": "files:upload";
|
|
251
|
+
"files:read": "files:read";
|
|
252
|
+
"documents:manage": "documents:manage";
|
|
253
|
+
"documents:search": "documents:search";
|
|
254
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
255
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
256
|
+
"github:manage": "github:manage";
|
|
257
|
+
"github:use": "github:use";
|
|
258
|
+
"api_keys:manage": "api_keys:manage";
|
|
259
|
+
"environments:manage": "environments:manage";
|
|
260
|
+
"environments:use": "environments:use";
|
|
261
|
+
"goals:manage": "goals:manage";
|
|
262
|
+
}>>;
|
|
263
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
264
|
+
}, z.core.$strip>>;
|
|
265
|
+
workspaceGrants: z.ZodArray<z.ZodObject<{
|
|
266
|
+
workspaceId: z.ZodString;
|
|
267
|
+
accountId: z.ZodString;
|
|
268
|
+
subjectId: z.ZodString;
|
|
269
|
+
subjectLabel: z.ZodOptional<z.ZodString>;
|
|
270
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
271
|
+
"account:read": "account:read";
|
|
272
|
+
"account:admin": "account:admin";
|
|
273
|
+
"members:manage": "members:manage";
|
|
274
|
+
"workspace:create": "workspace:create";
|
|
275
|
+
"billing:read": "billing:read";
|
|
276
|
+
"billing:manage": "billing:manage";
|
|
277
|
+
"workspace:read": "workspace:read";
|
|
278
|
+
"workspace:admin": "workspace:admin";
|
|
279
|
+
"sessions:create": "sessions:create";
|
|
280
|
+
"sessions:read": "sessions:read";
|
|
281
|
+
"sessions:control": "sessions:control";
|
|
282
|
+
"files:upload": "files:upload";
|
|
283
|
+
"files:read": "files:read";
|
|
284
|
+
"documents:manage": "documents:manage";
|
|
285
|
+
"documents:search": "documents:search";
|
|
286
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
287
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
288
|
+
"github:manage": "github:manage";
|
|
289
|
+
"github:use": "github:use";
|
|
290
|
+
"api_keys:manage": "api_keys:manage";
|
|
291
|
+
"environments:manage": "environments:manage";
|
|
292
|
+
"environments:use": "environments:use";
|
|
293
|
+
"goals:manage": "goals:manage";
|
|
294
|
+
}>>;
|
|
295
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
296
|
+
}, z.core.$strip>>;
|
|
297
|
+
defaultAccountId: z.ZodNullable<z.ZodString>;
|
|
298
|
+
defaultWorkspaceId: z.ZodNullable<z.ZodString>;
|
|
299
|
+
}, z.core.$strip>;
|
|
300
|
+
type AccessContext = z.infer<typeof AccessContext>;
|
|
301
|
+
declare const DelegatedAccessTokenPayload: z.ZodObject<{
|
|
302
|
+
accountId: z.ZodString;
|
|
303
|
+
workspaceId: z.ZodString;
|
|
304
|
+
subjectId: z.ZodString;
|
|
305
|
+
subjectLabel: z.ZodOptional<z.ZodString>;
|
|
306
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
307
|
+
"account:read": "account:read";
|
|
308
|
+
"account:admin": "account:admin";
|
|
309
|
+
"members:manage": "members:manage";
|
|
310
|
+
"workspace:create": "workspace:create";
|
|
311
|
+
"billing:read": "billing:read";
|
|
312
|
+
"billing:manage": "billing:manage";
|
|
313
|
+
"workspace:read": "workspace:read";
|
|
314
|
+
"workspace:admin": "workspace:admin";
|
|
315
|
+
"sessions:create": "sessions:create";
|
|
316
|
+
"sessions:read": "sessions:read";
|
|
317
|
+
"sessions:control": "sessions:control";
|
|
318
|
+
"files:upload": "files:upload";
|
|
319
|
+
"files:read": "files:read";
|
|
320
|
+
"documents:manage": "documents:manage";
|
|
321
|
+
"documents:search": "documents:search";
|
|
322
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
323
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
324
|
+
"github:manage": "github:manage";
|
|
325
|
+
"github:use": "github:use";
|
|
326
|
+
"api_keys:manage": "api_keys:manage";
|
|
327
|
+
"environments:manage": "environments:manage";
|
|
328
|
+
"environments:use": "environments:use";
|
|
329
|
+
"goals:manage": "goals:manage";
|
|
330
|
+
}>>;
|
|
331
|
+
sessionId: z.ZodOptional<z.ZodString>;
|
|
332
|
+
exp: z.ZodNumber;
|
|
333
|
+
}, z.core.$strip>;
|
|
334
|
+
type DelegatedAccessTokenPayload = z.infer<typeof DelegatedAccessTokenPayload>;
|
|
335
|
+
declare function signDelegatedAccessToken(secret: string, payload: DelegatedAccessTokenPayload): Promise<string>;
|
|
336
|
+
declare function verifyDelegatedAccessToken(secret: string, token: string, nowSeconds?: number): Promise<DelegatedAccessTokenPayload | null>;
|
|
337
|
+
declare const CreateWorkspaceRequest: z.ZodObject<{
|
|
338
|
+
accountId: z.ZodOptional<z.ZodString>;
|
|
339
|
+
name: z.ZodString;
|
|
340
|
+
slug: z.ZodOptional<z.ZodString>;
|
|
341
|
+
externalSource: z.ZodOptional<z.ZodString>;
|
|
342
|
+
externalId: z.ZodOptional<z.ZodString>;
|
|
343
|
+
agentInstructions: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
344
|
+
}, z.core.$strip>;
|
|
345
|
+
type CreateWorkspaceRequest = z.infer<typeof CreateWorkspaceRequest>;
|
|
346
|
+
declare const UpdateWorkspaceRequest: z.ZodObject<{
|
|
347
|
+
name: z.ZodOptional<z.ZodString>;
|
|
348
|
+
slug: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
349
|
+
agentInstructions: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
350
|
+
}, z.core.$strip>;
|
|
351
|
+
type UpdateWorkspaceRequest = z.infer<typeof UpdateWorkspaceRequest>;
|
|
352
|
+
declare const ApiKey: z.ZodObject<{
|
|
353
|
+
id: z.ZodString;
|
|
354
|
+
accountId: z.ZodString;
|
|
355
|
+
workspaceId: z.ZodNullable<z.ZodString>;
|
|
356
|
+
name: z.ZodString;
|
|
357
|
+
prefix: z.ZodString;
|
|
358
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
359
|
+
"account:read": "account:read";
|
|
360
|
+
"account:admin": "account:admin";
|
|
361
|
+
"members:manage": "members:manage";
|
|
362
|
+
"workspace:create": "workspace:create";
|
|
363
|
+
"billing:read": "billing:read";
|
|
364
|
+
"billing:manage": "billing:manage";
|
|
365
|
+
"workspace:read": "workspace:read";
|
|
366
|
+
"workspace:admin": "workspace:admin";
|
|
367
|
+
"sessions:create": "sessions:create";
|
|
368
|
+
"sessions:read": "sessions:read";
|
|
369
|
+
"sessions:control": "sessions:control";
|
|
370
|
+
"files:upload": "files:upload";
|
|
371
|
+
"files:read": "files:read";
|
|
372
|
+
"documents:manage": "documents:manage";
|
|
373
|
+
"documents:search": "documents:search";
|
|
374
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
375
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
376
|
+
"github:manage": "github:manage";
|
|
377
|
+
"github:use": "github:use";
|
|
378
|
+
"api_keys:manage": "api_keys:manage";
|
|
379
|
+
"environments:manage": "environments:manage";
|
|
380
|
+
"environments:use": "environments:use";
|
|
381
|
+
"goals:manage": "goals:manage";
|
|
382
|
+
}>>;
|
|
383
|
+
expiresAt: z.ZodNullable<z.ZodString>;
|
|
384
|
+
revokedAt: z.ZodNullable<z.ZodString>;
|
|
385
|
+
lastUsedAt: z.ZodNullable<z.ZodString>;
|
|
386
|
+
createdAt: z.ZodString;
|
|
387
|
+
updatedAt: z.ZodString;
|
|
388
|
+
}, z.core.$strip>;
|
|
389
|
+
type ApiKey = z.infer<typeof ApiKey>;
|
|
390
|
+
declare const CreateApiKeyRequest: z.ZodObject<{
|
|
391
|
+
name: z.ZodString;
|
|
392
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
393
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
394
|
+
"account:read": "account:read";
|
|
395
|
+
"account:admin": "account:admin";
|
|
396
|
+
"members:manage": "members:manage";
|
|
397
|
+
"workspace:create": "workspace:create";
|
|
398
|
+
"billing:read": "billing:read";
|
|
399
|
+
"billing:manage": "billing:manage";
|
|
400
|
+
"workspace:read": "workspace:read";
|
|
401
|
+
"workspace:admin": "workspace:admin";
|
|
402
|
+
"sessions:create": "sessions:create";
|
|
403
|
+
"sessions:read": "sessions:read";
|
|
404
|
+
"sessions:control": "sessions:control";
|
|
405
|
+
"files:upload": "files:upload";
|
|
406
|
+
"files:read": "files:read";
|
|
407
|
+
"documents:manage": "documents:manage";
|
|
408
|
+
"documents:search": "documents:search";
|
|
409
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
410
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
411
|
+
"github:manage": "github:manage";
|
|
412
|
+
"github:use": "github:use";
|
|
413
|
+
"api_keys:manage": "api_keys:manage";
|
|
414
|
+
"environments:manage": "environments:manage";
|
|
415
|
+
"environments:use": "environments:use";
|
|
416
|
+
"goals:manage": "goals:manage";
|
|
417
|
+
}>>;
|
|
418
|
+
expiresAt: z.ZodOptional<z.ZodString>;
|
|
419
|
+
}, z.core.$strip>;
|
|
420
|
+
type CreateApiKeyRequest = z.infer<typeof CreateApiKeyRequest>;
|
|
421
|
+
declare const CreateApiKeyResponse: z.ZodObject<{
|
|
422
|
+
apiKey: z.ZodObject<{
|
|
423
|
+
id: z.ZodString;
|
|
424
|
+
accountId: z.ZodString;
|
|
425
|
+
workspaceId: z.ZodNullable<z.ZodString>;
|
|
426
|
+
name: z.ZodString;
|
|
427
|
+
prefix: z.ZodString;
|
|
428
|
+
permissions: z.ZodArray<z.ZodEnum<{
|
|
429
|
+
"account:read": "account:read";
|
|
430
|
+
"account:admin": "account:admin";
|
|
431
|
+
"members:manage": "members:manage";
|
|
432
|
+
"workspace:create": "workspace:create";
|
|
433
|
+
"billing:read": "billing:read";
|
|
434
|
+
"billing:manage": "billing:manage";
|
|
435
|
+
"workspace:read": "workspace:read";
|
|
436
|
+
"workspace:admin": "workspace:admin";
|
|
437
|
+
"sessions:create": "sessions:create";
|
|
438
|
+
"sessions:read": "sessions:read";
|
|
439
|
+
"sessions:control": "sessions:control";
|
|
440
|
+
"files:upload": "files:upload";
|
|
441
|
+
"files:read": "files:read";
|
|
442
|
+
"documents:manage": "documents:manage";
|
|
443
|
+
"documents:search": "documents:search";
|
|
444
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
445
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
446
|
+
"github:manage": "github:manage";
|
|
447
|
+
"github:use": "github:use";
|
|
448
|
+
"api_keys:manage": "api_keys:manage";
|
|
449
|
+
"environments:manage": "environments:manage";
|
|
450
|
+
"environments:use": "environments:use";
|
|
451
|
+
"goals:manage": "goals:manage";
|
|
452
|
+
}>>;
|
|
453
|
+
expiresAt: z.ZodNullable<z.ZodString>;
|
|
454
|
+
revokedAt: z.ZodNullable<z.ZodString>;
|
|
455
|
+
lastUsedAt: z.ZodNullable<z.ZodString>;
|
|
456
|
+
createdAt: z.ZodString;
|
|
457
|
+
updatedAt: z.ZodString;
|
|
458
|
+
}, z.core.$strip>;
|
|
459
|
+
token: z.ZodString;
|
|
460
|
+
}, z.core.$strip>;
|
|
461
|
+
type CreateApiKeyResponse = z.infer<typeof CreateApiKeyResponse>;
|
|
462
|
+
declare const UsageEventType: z.ZodEnum<{
|
|
463
|
+
"agent_run.created": "agent_run.created";
|
|
464
|
+
"agent_run.completed": "agent_run.completed";
|
|
465
|
+
"model.tokens": "model.tokens";
|
|
466
|
+
"model.cost": "model.cost";
|
|
467
|
+
"file.uploaded": "file.uploaded";
|
|
468
|
+
"file.deleted": "file.deleted";
|
|
469
|
+
"document.indexed": "document.indexed";
|
|
470
|
+
"scheduled_task.fired": "scheduled_task.fired";
|
|
471
|
+
"api_key.request": "api_key.request";
|
|
472
|
+
}>;
|
|
473
|
+
type UsageEventType = z.infer<typeof UsageEventType>;
|
|
474
|
+
declare const UsageEvent: z.ZodObject<{
|
|
475
|
+
id: z.ZodString;
|
|
476
|
+
workspaceId: z.ZodString;
|
|
477
|
+
accountId: z.ZodString;
|
|
478
|
+
subjectId: z.ZodNullable<z.ZodString>;
|
|
479
|
+
eventType: z.ZodEnum<{
|
|
480
|
+
"agent_run.created": "agent_run.created";
|
|
481
|
+
"agent_run.completed": "agent_run.completed";
|
|
482
|
+
"model.tokens": "model.tokens";
|
|
483
|
+
"model.cost": "model.cost";
|
|
484
|
+
"file.uploaded": "file.uploaded";
|
|
485
|
+
"file.deleted": "file.deleted";
|
|
486
|
+
"document.indexed": "document.indexed";
|
|
487
|
+
"scheduled_task.fired": "scheduled_task.fired";
|
|
488
|
+
"api_key.request": "api_key.request";
|
|
489
|
+
}>;
|
|
490
|
+
quantity: z.ZodNumber;
|
|
491
|
+
unit: z.ZodString;
|
|
492
|
+
sourceResourceType: z.ZodNullable<z.ZodString>;
|
|
493
|
+
sourceResourceId: z.ZodNullable<z.ZodString>;
|
|
494
|
+
idempotencyKey: z.ZodString;
|
|
495
|
+
occurredAt: z.ZodString;
|
|
496
|
+
recordedAt: z.ZodString;
|
|
497
|
+
exportedToBillingAt: z.ZodNullable<z.ZodString>;
|
|
498
|
+
billingProviderEventId: z.ZodNullable<z.ZodString>;
|
|
499
|
+
}, z.core.$strip>;
|
|
500
|
+
type UsageEvent = z.infer<typeof UsageEvent>;
|
|
501
|
+
declare const LimitAction: z.ZodEnum<{
|
|
502
|
+
"workspace:create": "workspace:create";
|
|
503
|
+
"agent_run:create": "agent_run:create";
|
|
504
|
+
"tokens:consume": "tokens:consume";
|
|
505
|
+
"file:upload": "file:upload";
|
|
506
|
+
"document:index": "document:index";
|
|
507
|
+
"schedule:create": "schedule:create";
|
|
508
|
+
"api_key:create": "api_key:create";
|
|
509
|
+
}>;
|
|
510
|
+
type LimitAction = z.infer<typeof LimitAction>;
|
|
511
|
+
declare const StaticUsageLimits: z.ZodObject<{
|
|
512
|
+
maxWorkspacesPerAccount: z.ZodOptional<z.ZodNumber>;
|
|
513
|
+
maxApiKeysPerWorkspace: z.ZodOptional<z.ZodNumber>;
|
|
514
|
+
maxSchedulesPerWorkspace: z.ZodOptional<z.ZodNumber>;
|
|
515
|
+
maxFileUploadBytes: z.ZodOptional<z.ZodNumber>;
|
|
516
|
+
maxMonthlyAgentRunsPerWorkspace: z.ZodOptional<z.ZodNumber>;
|
|
517
|
+
maxMonthlyTokensPerWorkspace: z.ZodOptional<z.ZodNumber>;
|
|
518
|
+
maxMonthlyCostMicrosPerAccount: z.ZodOptional<z.ZodNumber>;
|
|
519
|
+
maxDocumentIndexedChunksPerWorkspace: z.ZodOptional<z.ZodNumber>;
|
|
520
|
+
}, z.core.$strip>;
|
|
521
|
+
type StaticUsageLimits = z.infer<typeof StaticUsageLimits>;
|
|
522
|
+
declare const EntitlementValue: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>]>;
|
|
523
|
+
type EntitlementValue = z.infer<typeof EntitlementValue>;
|
|
524
|
+
declare const Entitlements: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>]>>;
|
|
525
|
+
type Entitlements = z.infer<typeof Entitlements>;
|
|
526
|
+
declare const LimitDecision: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
527
|
+
allowed: z.ZodLiteral<true>;
|
|
528
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
529
|
+
allowed: z.ZodLiteral<false>;
|
|
530
|
+
code: z.ZodString;
|
|
531
|
+
message: z.ZodString;
|
|
532
|
+
}, z.core.$strip>], "allowed">;
|
|
533
|
+
type LimitDecision = z.infer<typeof LimitDecision>;
|
|
534
|
+
declare const BillingBalance: z.ZodObject<{
|
|
535
|
+
accountId: z.ZodString;
|
|
536
|
+
balanceMicros: z.ZodNumber;
|
|
537
|
+
currency: z.ZodLiteral<"usd">;
|
|
538
|
+
updatedAt: z.ZodString;
|
|
539
|
+
}, z.core.$strip>;
|
|
540
|
+
type BillingBalance = z.infer<typeof BillingBalance>;
|
|
541
|
+
declare const CreateCheckoutRequest: z.ZodObject<{
|
|
542
|
+
accountId: z.ZodOptional<z.ZodString>;
|
|
543
|
+
amountUsd: z.ZodNumber;
|
|
544
|
+
successUrl: z.ZodOptional<z.ZodString>;
|
|
545
|
+
cancelUrl: z.ZodOptional<z.ZodString>;
|
|
546
|
+
}, z.core.$strip>;
|
|
547
|
+
type CreateCheckoutRequest = z.infer<typeof CreateCheckoutRequest>;
|
|
548
|
+
declare const CreateCheckoutResponse: z.ZodObject<{
|
|
549
|
+
checkoutSessionId: z.ZodString;
|
|
550
|
+
url: z.ZodString;
|
|
551
|
+
}, z.core.$strip>;
|
|
552
|
+
type CreateCheckoutResponse = z.infer<typeof CreateCheckoutResponse>;
|
|
553
|
+
declare const RepositoryResourceRef: z.ZodObject<{
|
|
554
|
+
kind: z.ZodLiteral<"repository">;
|
|
555
|
+
uri: z.ZodString;
|
|
556
|
+
ref: z.ZodString;
|
|
557
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
558
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
559
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
560
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
561
|
+
}, z.core.$strip>;
|
|
562
|
+
type RepositoryResourceRef = z.infer<typeof RepositoryResourceRef>;
|
|
563
|
+
declare const FileResourceRef: z.ZodObject<{
|
|
564
|
+
kind: z.ZodLiteral<"file">;
|
|
565
|
+
fileId: z.ZodString;
|
|
566
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
567
|
+
}, z.core.$strip>;
|
|
568
|
+
type FileResourceRef = z.infer<typeof FileResourceRef>;
|
|
569
|
+
declare const ResourceRef: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
570
|
+
kind: z.ZodLiteral<"repository">;
|
|
571
|
+
uri: z.ZodString;
|
|
572
|
+
ref: z.ZodString;
|
|
573
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
574
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
575
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
576
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
577
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
578
|
+
kind: z.ZodLiteral<"file">;
|
|
579
|
+
fileId: z.ZodString;
|
|
580
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
581
|
+
}, z.core.$strip>], "kind">;
|
|
582
|
+
type ResourceRef = z.infer<typeof ResourceRef>;
|
|
583
|
+
declare const FileStatus: z.ZodEnum<{
|
|
584
|
+
failed: "failed";
|
|
585
|
+
pending_upload: "pending_upload";
|
|
586
|
+
ready: "ready";
|
|
587
|
+
expired: "expired";
|
|
588
|
+
deleted: "deleted";
|
|
589
|
+
}>;
|
|
590
|
+
type FileStatus = z.infer<typeof FileStatus>;
|
|
591
|
+
declare const FileUploadStatus: z.ZodEnum<{
|
|
592
|
+
failed: "failed";
|
|
593
|
+
expired: "expired";
|
|
594
|
+
pending: "pending";
|
|
595
|
+
completed: "completed";
|
|
596
|
+
}>;
|
|
597
|
+
type FileUploadStatus = z.infer<typeof FileUploadStatus>;
|
|
598
|
+
declare const FileAsset: z.ZodObject<{
|
|
599
|
+
id: z.ZodString;
|
|
600
|
+
workspaceId: z.ZodString;
|
|
601
|
+
status: z.ZodEnum<{
|
|
602
|
+
failed: "failed";
|
|
603
|
+
pending_upload: "pending_upload";
|
|
604
|
+
ready: "ready";
|
|
605
|
+
expired: "expired";
|
|
606
|
+
deleted: "deleted";
|
|
607
|
+
}>;
|
|
608
|
+
filename: z.ZodString;
|
|
609
|
+
safeFilename: z.ZodString;
|
|
610
|
+
contentType: z.ZodString;
|
|
611
|
+
sizeBytes: z.ZodNumber;
|
|
612
|
+
sha256: z.ZodNullable<z.ZodString>;
|
|
613
|
+
bucket: z.ZodString;
|
|
614
|
+
objectKey: z.ZodString;
|
|
615
|
+
createdAt: z.ZodString;
|
|
616
|
+
updatedAt: z.ZodString;
|
|
617
|
+
}, z.core.$strip>;
|
|
618
|
+
type FileAsset = z.infer<typeof FileAsset>;
|
|
619
|
+
declare const CreateFileUploadRequest: z.ZodObject<{
|
|
620
|
+
filename: z.ZodString;
|
|
621
|
+
contentType: z.ZodString;
|
|
622
|
+
sizeBytes: z.ZodNumber;
|
|
623
|
+
sha256: z.ZodOptional<z.ZodString>;
|
|
624
|
+
}, z.core.$strip>;
|
|
625
|
+
type CreateFileUploadRequest = z.infer<typeof CreateFileUploadRequest>;
|
|
626
|
+
declare const CreateFileUploadResponse: z.ZodObject<{
|
|
627
|
+
fileId: z.ZodString;
|
|
628
|
+
uploadId: z.ZodString;
|
|
629
|
+
putUrl: z.ZodString;
|
|
630
|
+
requiredHeaders: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
631
|
+
expiresAt: z.ZodString;
|
|
632
|
+
maxSizeBytes: z.ZodNumber;
|
|
633
|
+
}, z.core.$strip>;
|
|
634
|
+
type CreateFileUploadResponse = z.infer<typeof CreateFileUploadResponse>;
|
|
635
|
+
declare const CompleteFileUploadResponse: z.ZodObject<{
|
|
636
|
+
file: z.ZodObject<{
|
|
637
|
+
id: z.ZodString;
|
|
638
|
+
workspaceId: z.ZodString;
|
|
639
|
+
status: z.ZodEnum<{
|
|
640
|
+
failed: "failed";
|
|
641
|
+
pending_upload: "pending_upload";
|
|
642
|
+
ready: "ready";
|
|
643
|
+
expired: "expired";
|
|
644
|
+
deleted: "deleted";
|
|
645
|
+
}>;
|
|
646
|
+
filename: z.ZodString;
|
|
647
|
+
safeFilename: z.ZodString;
|
|
648
|
+
contentType: z.ZodString;
|
|
649
|
+
sizeBytes: z.ZodNumber;
|
|
650
|
+
sha256: z.ZodNullable<z.ZodString>;
|
|
651
|
+
bucket: z.ZodString;
|
|
652
|
+
objectKey: z.ZodString;
|
|
653
|
+
createdAt: z.ZodString;
|
|
654
|
+
updatedAt: z.ZodString;
|
|
655
|
+
}, z.core.$strip>;
|
|
656
|
+
}, z.core.$strip>;
|
|
657
|
+
type CompleteFileUploadResponse = z.infer<typeof CompleteFileUploadResponse>;
|
|
658
|
+
declare const FileDownloadUrlResponse: z.ZodObject<{
|
|
659
|
+
url: z.ZodString;
|
|
660
|
+
expiresAt: z.ZodString;
|
|
661
|
+
}, z.core.$strip>;
|
|
662
|
+
type FileDownloadUrlResponse = z.infer<typeof FileDownloadUrlResponse>;
|
|
663
|
+
declare const DocumentStatus: z.ZodEnum<{
|
|
664
|
+
queued: "queued";
|
|
665
|
+
failed: "failed";
|
|
666
|
+
ready: "ready";
|
|
667
|
+
indexing: "indexing";
|
|
668
|
+
}>;
|
|
669
|
+
type DocumentStatus = z.infer<typeof DocumentStatus>;
|
|
670
|
+
declare const DocumentBase: z.ZodObject<{
|
|
671
|
+
id: z.ZodString;
|
|
672
|
+
workspaceId: z.ZodString;
|
|
673
|
+
name: z.ZodString;
|
|
674
|
+
description: z.ZodNullable<z.ZodString>;
|
|
675
|
+
createdAt: z.ZodString;
|
|
676
|
+
updatedAt: z.ZodString;
|
|
677
|
+
}, z.core.$strip>;
|
|
678
|
+
type DocumentBase = z.infer<typeof DocumentBase>;
|
|
679
|
+
declare const Document: z.ZodObject<{
|
|
680
|
+
id: z.ZodString;
|
|
681
|
+
workspaceId: z.ZodString;
|
|
682
|
+
baseId: z.ZodString;
|
|
683
|
+
fileId: z.ZodString;
|
|
684
|
+
status: z.ZodEnum<{
|
|
685
|
+
queued: "queued";
|
|
686
|
+
failed: "failed";
|
|
687
|
+
ready: "ready";
|
|
688
|
+
indexing: "indexing";
|
|
689
|
+
}>;
|
|
690
|
+
title: z.ZodString;
|
|
691
|
+
parser: z.ZodString;
|
|
692
|
+
chunkCount: z.ZodNumber;
|
|
693
|
+
error: z.ZodNullable<z.ZodString>;
|
|
694
|
+
createdAt: z.ZodString;
|
|
695
|
+
updatedAt: z.ZodString;
|
|
696
|
+
}, z.core.$strip>;
|
|
697
|
+
type Document = z.infer<typeof Document>;
|
|
698
|
+
declare const DocumentSearchResult: z.ZodObject<{
|
|
699
|
+
chunkId: z.ZodString;
|
|
700
|
+
workspaceId: z.ZodString;
|
|
701
|
+
documentId: z.ZodString;
|
|
702
|
+
baseId: z.ZodString;
|
|
703
|
+
fileId: z.ZodString;
|
|
704
|
+
title: z.ZodString;
|
|
705
|
+
text: z.ZodString;
|
|
706
|
+
score: z.ZodNumber;
|
|
707
|
+
chunkIndex: z.ZodNumber;
|
|
708
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
709
|
+
}, z.core.$strip>;
|
|
710
|
+
type DocumentSearchResult = z.infer<typeof DocumentSearchResult>;
|
|
711
|
+
declare const CreateDocumentBaseRequest: z.ZodObject<{
|
|
712
|
+
name: z.ZodString;
|
|
713
|
+
description: z.ZodOptional<z.ZodString>;
|
|
714
|
+
}, z.core.$strip>;
|
|
715
|
+
type CreateDocumentBaseRequest = z.infer<typeof CreateDocumentBaseRequest>;
|
|
716
|
+
declare const AddDocumentRequest: z.ZodObject<{
|
|
717
|
+
fileId: z.ZodString;
|
|
718
|
+
}, z.core.$strip>;
|
|
719
|
+
type AddDocumentRequest = z.infer<typeof AddDocumentRequest>;
|
|
720
|
+
declare const DocumentSearchRequest: z.ZodObject<{
|
|
721
|
+
query: z.ZodString;
|
|
722
|
+
limit: z.ZodDefault<z.ZodNumber>;
|
|
723
|
+
}, z.core.$strip>;
|
|
724
|
+
type DocumentSearchRequest = z.infer<typeof DocumentSearchRequest>;
|
|
725
|
+
declare const ToolRef: z.ZodObject<{
|
|
726
|
+
kind: z.ZodLiteral<"mcp">;
|
|
727
|
+
id: z.ZodString;
|
|
728
|
+
}, z.core.$strip>;
|
|
729
|
+
type ToolRef = z.infer<typeof ToolRef>;
|
|
730
|
+
declare class ResourceRefConflictError extends Error {
|
|
731
|
+
constructor(message: string);
|
|
732
|
+
}
|
|
733
|
+
declare function mergeToolRefs(existing: ToolRef[], additions: ToolRef[]): ToolRef[];
|
|
734
|
+
declare function mergeResourceRefs(existing: ResourceRef[], additions: ResourceRef[], options?: {
|
|
735
|
+
rejectConflicts?: boolean;
|
|
736
|
+
}): ResourceRef[];
|
|
737
|
+
declare function reasoningEffortForMetadata(metadata: Record<string, unknown>, fallback: ReasoningEffort): ReasoningEffort;
|
|
738
|
+
declare function stableJson(value: unknown): string;
|
|
739
|
+
declare function resourceIdentityKey(resource: ResourceRef): string;
|
|
740
|
+
declare const SessionTurnStatus: z.ZodEnum<{
|
|
741
|
+
queued: "queued";
|
|
742
|
+
running: "running";
|
|
743
|
+
requires_action: "requires_action";
|
|
744
|
+
failed: "failed";
|
|
745
|
+
cancelled: "cancelled";
|
|
746
|
+
completed: "completed";
|
|
747
|
+
}>;
|
|
748
|
+
type SessionTurnStatus = z.infer<typeof SessionTurnStatus>;
|
|
749
|
+
declare const SessionTurnSource: z.ZodEnum<{
|
|
750
|
+
user: "user";
|
|
751
|
+
scheduled_task: "scheduled_task";
|
|
752
|
+
api: "api";
|
|
753
|
+
goal: "goal";
|
|
754
|
+
}>;
|
|
755
|
+
type SessionTurnSource = z.infer<typeof SessionTurnSource>;
|
|
756
|
+
declare const SessionGoalStatus: z.ZodEnum<{
|
|
757
|
+
completed: "completed";
|
|
758
|
+
active: "active";
|
|
759
|
+
paused: "paused";
|
|
760
|
+
}>;
|
|
761
|
+
type SessionGoalStatus = z.infer<typeof SessionGoalStatus>;
|
|
762
|
+
declare const SessionGoalCreatedBy: z.ZodEnum<{
|
|
763
|
+
scheduled_task: "scheduled_task";
|
|
764
|
+
api: "api";
|
|
765
|
+
agent: "agent";
|
|
766
|
+
}>;
|
|
767
|
+
type SessionGoalCreatedBy = z.infer<typeof SessionGoalCreatedBy>;
|
|
768
|
+
declare const SessionGoalPausedReason: z.ZodEnum<{
|
|
769
|
+
api: "api";
|
|
770
|
+
agent: "agent";
|
|
771
|
+
user_interrupt: "user_interrupt";
|
|
772
|
+
no_progress: "no_progress";
|
|
773
|
+
max_auto_continuations: "max_auto_continuations";
|
|
774
|
+
limits: "limits";
|
|
775
|
+
}>;
|
|
776
|
+
type SessionGoalPausedReason = z.infer<typeof SessionGoalPausedReason>;
|
|
777
|
+
declare const SessionGoal: z.ZodObject<{
|
|
778
|
+
id: z.ZodString;
|
|
779
|
+
accountId: z.ZodString;
|
|
780
|
+
workspaceId: z.ZodString;
|
|
781
|
+
sessionId: z.ZodString;
|
|
782
|
+
status: z.ZodEnum<{
|
|
783
|
+
completed: "completed";
|
|
784
|
+
active: "active";
|
|
785
|
+
paused: "paused";
|
|
786
|
+
}>;
|
|
787
|
+
text: z.ZodString;
|
|
788
|
+
successCriteria: z.ZodNullable<z.ZodString>;
|
|
789
|
+
evidence: z.ZodNullable<z.ZodString>;
|
|
790
|
+
rationale: z.ZodNullable<z.ZodString>;
|
|
791
|
+
pausedReason: z.ZodNullable<z.ZodString>;
|
|
792
|
+
createdBy: z.ZodEnum<{
|
|
793
|
+
scheduled_task: "scheduled_task";
|
|
794
|
+
api: "api";
|
|
795
|
+
agent: "agent";
|
|
796
|
+
}>;
|
|
797
|
+
version: z.ZodNumber;
|
|
798
|
+
autoContinuations: z.ZodNumber;
|
|
799
|
+
noProgressStreak: z.ZodNumber;
|
|
800
|
+
maxAutoContinuations: z.ZodNullable<z.ZodNumber>;
|
|
801
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
802
|
+
createdAt: z.ZodString;
|
|
803
|
+
updatedAt: z.ZodString;
|
|
804
|
+
}, z.core.$strip>;
|
|
805
|
+
type SessionGoal = z.infer<typeof SessionGoal>;
|
|
806
|
+
declare const GoalSpec: z.ZodObject<{
|
|
807
|
+
text: z.ZodString;
|
|
808
|
+
successCriteria: z.ZodOptional<z.ZodString>;
|
|
809
|
+
maxAutoContinuations: z.ZodOptional<z.ZodNumber>;
|
|
810
|
+
}, z.core.$strip>;
|
|
811
|
+
type GoalSpec = z.infer<typeof GoalSpec>;
|
|
812
|
+
declare const UpdateSessionGoalRequest: z.ZodObject<{
|
|
813
|
+
status: z.ZodEnum<{
|
|
814
|
+
active: "active";
|
|
815
|
+
paused: "paused";
|
|
816
|
+
}>;
|
|
817
|
+
rationale: z.ZodOptional<z.ZodString>;
|
|
818
|
+
}, z.core.$strip>;
|
|
819
|
+
type UpdateSessionGoalRequest = z.infer<typeof UpdateSessionGoalRequest>;
|
|
820
|
+
/**
|
|
821
|
+
* Clear a session's conversation context. `confirm` must be the literal `true`
|
|
822
|
+
* so an accidental/empty POST cannot wipe context — the destructive intent is
|
|
823
|
+
* explicit on the wire, mirroring the client-side confirm affordance.
|
|
824
|
+
*/
|
|
825
|
+
declare const ClearSessionContextRequest: z.ZodObject<{
|
|
826
|
+
confirm: z.ZodLiteral<true>;
|
|
827
|
+
}, z.core.$strip>;
|
|
828
|
+
type ClearSessionContextRequest = z.infer<typeof ClearSessionContextRequest>;
|
|
829
|
+
/**
|
|
830
|
+
* The marker key on the sentinel run-state blob written by a context clear. The
|
|
831
|
+
* blob ({@link CLEARED_RUN_STATE_BLOB}) is NOT a real Agents-SDK serialized run
|
|
832
|
+
* state — it carries no `$schemaVersion`/history, so `RunState.fromString` would
|
|
833
|
+
* throw on it. Every read path that deserializes a run-state blob MUST first
|
|
834
|
+
* check {@link isClearedRunStateBlob} and treat a match as "no prior state"
|
|
835
|
+
* (a fresh, empty start), which is exactly what a clear means. This is the
|
|
836
|
+
* shared contract that keeps the db (writer) and the runtime (reader) in sync.
|
|
837
|
+
*/
|
|
838
|
+
declare const CLEARED_RUN_STATE_MARKER: "$opengeniCleared";
|
|
839
|
+
/** The canonical sentinel serializedRunState value a context clear stores. */
|
|
840
|
+
declare const CLEARED_RUN_STATE_BLOB: string;
|
|
841
|
+
/**
|
|
842
|
+
* True when a serialized run-state blob is the cleared sentinel rather than a
|
|
843
|
+
* real Agents-SDK run state. Recognized leniently (any object carrying the
|
|
844
|
+
* marker key set truthy) so a future field addition to the sentinel does not
|
|
845
|
+
* resurrect the pre-clear context. Anything that is not the sentinel — including
|
|
846
|
+
* malformed JSON — returns false so genuine blobs/corruption are handled by the
|
|
847
|
+
* normal deserialize path.
|
|
848
|
+
*/
|
|
849
|
+
declare function isClearedRunStateBlob(serialized: string | null | undefined): boolean;
|
|
850
|
+
/** Trigger conversation compaction now. No body fields today (forward-room). */
|
|
851
|
+
declare const CompactSessionContextRequest: z.ZodObject<{}, z.core.$strict>;
|
|
852
|
+
type CompactSessionContextRequest = z.infer<typeof CompactSessionContextRequest>;
|
|
853
|
+
/** Outcome of a manual /compact trigger. */
|
|
854
|
+
declare const CompactSessionContextResult: z.ZodObject<{
|
|
855
|
+
status: z.ZodEnum<{
|
|
856
|
+
queued: "queued";
|
|
857
|
+
noop: "noop";
|
|
858
|
+
}>;
|
|
859
|
+
message: z.ZodString;
|
|
860
|
+
}, z.core.$strip>;
|
|
861
|
+
type CompactSessionContextResult = z.infer<typeof CompactSessionContextResult>;
|
|
862
|
+
declare const SessionTurn: z.ZodObject<{
|
|
863
|
+
id: z.ZodString;
|
|
864
|
+
workspaceId: z.ZodString;
|
|
865
|
+
sessionId: z.ZodString;
|
|
866
|
+
triggerEventId: z.ZodString;
|
|
867
|
+
temporalWorkflowId: z.ZodString;
|
|
868
|
+
status: z.ZodEnum<{
|
|
869
|
+
queued: "queued";
|
|
870
|
+
running: "running";
|
|
871
|
+
requires_action: "requires_action";
|
|
872
|
+
failed: "failed";
|
|
873
|
+
cancelled: "cancelled";
|
|
874
|
+
completed: "completed";
|
|
875
|
+
}>;
|
|
876
|
+
source: z.ZodEnum<{
|
|
877
|
+
user: "user";
|
|
878
|
+
scheduled_task: "scheduled_task";
|
|
879
|
+
api: "api";
|
|
880
|
+
goal: "goal";
|
|
881
|
+
}>;
|
|
882
|
+
position: z.ZodNumber;
|
|
883
|
+
prompt: z.ZodString;
|
|
884
|
+
resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
885
|
+
kind: z.ZodLiteral<"repository">;
|
|
886
|
+
uri: z.ZodString;
|
|
887
|
+
ref: z.ZodString;
|
|
888
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
889
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
890
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
891
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
892
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
893
|
+
kind: z.ZodLiteral<"file">;
|
|
894
|
+
fileId: z.ZodString;
|
|
895
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
896
|
+
}, z.core.$strip>], "kind">>;
|
|
897
|
+
tools: z.ZodArray<z.ZodObject<{
|
|
898
|
+
kind: z.ZodLiteral<"mcp">;
|
|
899
|
+
id: z.ZodString;
|
|
900
|
+
}, z.core.$strip>>;
|
|
901
|
+
model: z.ZodString;
|
|
902
|
+
reasoningEffort: z.ZodEnum<{
|
|
903
|
+
none: "none";
|
|
904
|
+
minimal: "minimal";
|
|
905
|
+
low: "low";
|
|
906
|
+
medium: "medium";
|
|
907
|
+
high: "high";
|
|
908
|
+
xhigh: "xhigh";
|
|
909
|
+
}>;
|
|
910
|
+
sandboxBackend: z.ZodEnum<{
|
|
911
|
+
docker: "docker";
|
|
912
|
+
modal: "modal";
|
|
913
|
+
local: "local";
|
|
914
|
+
none: "none";
|
|
915
|
+
}>;
|
|
916
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
917
|
+
startedAt: z.ZodNullable<z.ZodString>;
|
|
918
|
+
finishedAt: z.ZodNullable<z.ZodString>;
|
|
919
|
+
createdAt: z.ZodString;
|
|
920
|
+
updatedAt: z.ZodString;
|
|
921
|
+
}, z.core.$strip>;
|
|
922
|
+
type SessionTurn = z.infer<typeof SessionTurn>;
|
|
923
|
+
declare const UpdateSessionTurnRequest: z.ZodObject<{
|
|
924
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
925
|
+
resources: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
926
|
+
kind: z.ZodLiteral<"repository">;
|
|
927
|
+
uri: z.ZodString;
|
|
928
|
+
ref: z.ZodString;
|
|
929
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
930
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
931
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
932
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
933
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
934
|
+
kind: z.ZodLiteral<"file">;
|
|
935
|
+
fileId: z.ZodString;
|
|
936
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
937
|
+
}, z.core.$strip>], "kind">>>;
|
|
938
|
+
tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
939
|
+
kind: z.ZodLiteral<"mcp">;
|
|
940
|
+
id: z.ZodString;
|
|
941
|
+
}, z.core.$strip>>>;
|
|
942
|
+
model: z.ZodOptional<z.ZodString>;
|
|
943
|
+
reasoningEffort: z.ZodOptional<z.ZodEnum<{
|
|
944
|
+
none: "none";
|
|
945
|
+
minimal: "minimal";
|
|
946
|
+
low: "low";
|
|
947
|
+
medium: "medium";
|
|
948
|
+
high: "high";
|
|
949
|
+
xhigh: "xhigh";
|
|
950
|
+
}>>;
|
|
951
|
+
sandboxBackend: z.ZodOptional<z.ZodEnum<{
|
|
952
|
+
docker: "docker";
|
|
953
|
+
modal: "modal";
|
|
954
|
+
local: "local";
|
|
955
|
+
none: "none";
|
|
956
|
+
}>>;
|
|
957
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
958
|
+
}, z.core.$strip>;
|
|
959
|
+
type UpdateSessionTurnRequest = z.infer<typeof UpdateSessionTurnRequest>;
|
|
960
|
+
declare const ReorderSessionTurnsRequest: z.ZodObject<{
|
|
961
|
+
turnIds: z.ZodArray<z.ZodString>;
|
|
962
|
+
}, z.core.$strip>;
|
|
963
|
+
type ReorderSessionTurnsRequest = z.infer<typeof ReorderSessionTurnsRequest>;
|
|
964
|
+
declare const WorkspaceEnvironmentVariableName: z.ZodString;
|
|
965
|
+
type WorkspaceEnvironmentVariableName = z.infer<typeof WorkspaceEnvironmentVariableName>;
|
|
966
|
+
declare const WorkspaceEnvironmentVariableMetadata: z.ZodObject<{
|
|
967
|
+
name: z.ZodString;
|
|
968
|
+
version: z.ZodNumber;
|
|
969
|
+
createdAt: z.ZodString;
|
|
970
|
+
updatedAt: z.ZodString;
|
|
971
|
+
}, z.core.$strip>;
|
|
972
|
+
type WorkspaceEnvironmentVariableMetadata = z.infer<typeof WorkspaceEnvironmentVariableMetadata>;
|
|
973
|
+
declare const WorkspaceEnvironment: z.ZodObject<{
|
|
974
|
+
id: z.ZodString;
|
|
975
|
+
accountId: z.ZodString;
|
|
976
|
+
workspaceId: z.ZodString;
|
|
977
|
+
name: z.ZodString;
|
|
978
|
+
description: z.ZodNullable<z.ZodString>;
|
|
979
|
+
variables: z.ZodArray<z.ZodObject<{
|
|
980
|
+
name: z.ZodString;
|
|
981
|
+
version: z.ZodNumber;
|
|
982
|
+
createdAt: z.ZodString;
|
|
983
|
+
updatedAt: z.ZodString;
|
|
984
|
+
}, z.core.$strip>>;
|
|
985
|
+
createdAt: z.ZodString;
|
|
986
|
+
updatedAt: z.ZodString;
|
|
987
|
+
}, z.core.$strip>;
|
|
988
|
+
type WorkspaceEnvironment = z.infer<typeof WorkspaceEnvironment>;
|
|
989
|
+
declare const CreateWorkspaceEnvironmentRequest: z.ZodObject<{
|
|
990
|
+
name: z.ZodString;
|
|
991
|
+
description: z.ZodOptional<z.ZodString>;
|
|
992
|
+
variables: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
993
|
+
name: z.ZodString;
|
|
994
|
+
value: z.ZodString;
|
|
995
|
+
}, z.core.$strip>>>;
|
|
996
|
+
}, z.core.$strip>;
|
|
997
|
+
type CreateWorkspaceEnvironmentRequest = z.infer<typeof CreateWorkspaceEnvironmentRequest>;
|
|
998
|
+
declare const UpdateWorkspaceEnvironmentRequest: z.ZodObject<{
|
|
999
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1000
|
+
description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
1001
|
+
}, z.core.$strip>;
|
|
1002
|
+
type UpdateWorkspaceEnvironmentRequest = z.infer<typeof UpdateWorkspaceEnvironmentRequest>;
|
|
1003
|
+
declare const SetWorkspaceEnvironmentVariableRequest: z.ZodObject<{
|
|
1004
|
+
value: z.ZodString;
|
|
1005
|
+
}, z.core.$strip>;
|
|
1006
|
+
type SetWorkspaceEnvironmentVariableRequest = z.infer<typeof SetWorkspaceEnvironmentVariableRequest>;
|
|
1007
|
+
declare const ScheduledTaskStatus: z.ZodEnum<{
|
|
1008
|
+
active: "active";
|
|
1009
|
+
paused: "paused";
|
|
1010
|
+
}>;
|
|
1011
|
+
type ScheduledTaskStatus = z.infer<typeof ScheduledTaskStatus>;
|
|
1012
|
+
declare const ScheduledTaskRunStatus: z.ZodEnum<{
|
|
1013
|
+
queued: "queued";
|
|
1014
|
+
failed: "failed";
|
|
1015
|
+
dispatched: "dispatched";
|
|
1016
|
+
}>;
|
|
1017
|
+
type ScheduledTaskRunStatus = z.infer<typeof ScheduledTaskRunStatus>;
|
|
1018
|
+
declare const ScheduledTaskRunMode: z.ZodEnum<{
|
|
1019
|
+
new_session_per_run: "new_session_per_run";
|
|
1020
|
+
reusable_session: "reusable_session";
|
|
1021
|
+
}>;
|
|
1022
|
+
type ScheduledTaskRunMode = z.infer<typeof ScheduledTaskRunMode>;
|
|
1023
|
+
declare const ScheduledTaskOverlapPolicy: z.ZodEnum<{
|
|
1024
|
+
allow_concurrent: "allow_concurrent";
|
|
1025
|
+
skip: "skip";
|
|
1026
|
+
buffer_one: "buffer_one";
|
|
1027
|
+
}>;
|
|
1028
|
+
type ScheduledTaskOverlapPolicy = z.infer<typeof ScheduledTaskOverlapPolicy>;
|
|
1029
|
+
declare const ScheduledTaskTriggerType: z.ZodEnum<{
|
|
1030
|
+
scheduled: "scheduled";
|
|
1031
|
+
manual: "manual";
|
|
1032
|
+
}>;
|
|
1033
|
+
type ScheduledTaskTriggerType = z.infer<typeof ScheduledTaskTriggerType>;
|
|
1034
|
+
declare const ScheduledTaskScheduleSpec: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1035
|
+
type: z.ZodLiteral<"once">;
|
|
1036
|
+
runAt: z.ZodString;
|
|
1037
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1038
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1039
|
+
type: z.ZodLiteral<"interval">;
|
|
1040
|
+
everySeconds: z.ZodNumber;
|
|
1041
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1042
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1043
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1044
|
+
type: z.ZodLiteral<"calendar">;
|
|
1045
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1046
|
+
hour: z.ZodNumber;
|
|
1047
|
+
minute: z.ZodNumber;
|
|
1048
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1049
|
+
SUNDAY: "SUNDAY";
|
|
1050
|
+
MONDAY: "MONDAY";
|
|
1051
|
+
TUESDAY: "TUESDAY";
|
|
1052
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1053
|
+
THURSDAY: "THURSDAY";
|
|
1054
|
+
FRIDAY: "FRIDAY";
|
|
1055
|
+
SATURDAY: "SATURDAY";
|
|
1056
|
+
}>>>;
|
|
1057
|
+
}, z.core.$strip>], "type">;
|
|
1058
|
+
type ScheduledTaskScheduleSpec = z.infer<typeof ScheduledTaskScheduleSpec>;
|
|
1059
|
+
declare const ScheduledTaskAgentConfig: z.ZodObject<{
|
|
1060
|
+
prompt: z.ZodString;
|
|
1061
|
+
resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1062
|
+
kind: z.ZodLiteral<"repository">;
|
|
1063
|
+
uri: z.ZodString;
|
|
1064
|
+
ref: z.ZodString;
|
|
1065
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1066
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
1067
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
1068
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
1069
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1070
|
+
kind: z.ZodLiteral<"file">;
|
|
1071
|
+
fileId: z.ZodString;
|
|
1072
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1073
|
+
}, z.core.$strip>], "kind">>>;
|
|
1074
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1075
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1076
|
+
id: z.ZodString;
|
|
1077
|
+
}, z.core.$strip>>>;
|
|
1078
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1079
|
+
model: z.ZodOptional<z.ZodString>;
|
|
1080
|
+
reasoningEffort: z.ZodOptional<z.ZodEnum<{
|
|
1081
|
+
none: "none";
|
|
1082
|
+
minimal: "minimal";
|
|
1083
|
+
low: "low";
|
|
1084
|
+
medium: "medium";
|
|
1085
|
+
high: "high";
|
|
1086
|
+
xhigh: "xhigh";
|
|
1087
|
+
}>>;
|
|
1088
|
+
sandboxBackend: z.ZodOptional<z.ZodEnum<{
|
|
1089
|
+
docker: "docker";
|
|
1090
|
+
modal: "modal";
|
|
1091
|
+
local: "local";
|
|
1092
|
+
none: "none";
|
|
1093
|
+
}>>;
|
|
1094
|
+
goal: z.ZodOptional<z.ZodObject<{
|
|
1095
|
+
text: z.ZodString;
|
|
1096
|
+
successCriteria: z.ZodOptional<z.ZodString>;
|
|
1097
|
+
maxAutoContinuations: z.ZodOptional<z.ZodNumber>;
|
|
1098
|
+
}, z.core.$strip>>;
|
|
1099
|
+
}, z.core.$strip>;
|
|
1100
|
+
type ScheduledTaskAgentConfig = z.infer<typeof ScheduledTaskAgentConfig>;
|
|
1101
|
+
declare const ScheduledTask: z.ZodObject<{
|
|
1102
|
+
id: z.ZodString;
|
|
1103
|
+
accountId: z.ZodString;
|
|
1104
|
+
workspaceId: z.ZodString;
|
|
1105
|
+
name: z.ZodString;
|
|
1106
|
+
status: z.ZodEnum<{
|
|
1107
|
+
active: "active";
|
|
1108
|
+
paused: "paused";
|
|
1109
|
+
}>;
|
|
1110
|
+
schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1111
|
+
type: z.ZodLiteral<"once">;
|
|
1112
|
+
runAt: z.ZodString;
|
|
1113
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1114
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1115
|
+
type: z.ZodLiteral<"interval">;
|
|
1116
|
+
everySeconds: z.ZodNumber;
|
|
1117
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1118
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1119
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1120
|
+
type: z.ZodLiteral<"calendar">;
|
|
1121
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1122
|
+
hour: z.ZodNumber;
|
|
1123
|
+
minute: z.ZodNumber;
|
|
1124
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1125
|
+
SUNDAY: "SUNDAY";
|
|
1126
|
+
MONDAY: "MONDAY";
|
|
1127
|
+
TUESDAY: "TUESDAY";
|
|
1128
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1129
|
+
THURSDAY: "THURSDAY";
|
|
1130
|
+
FRIDAY: "FRIDAY";
|
|
1131
|
+
SATURDAY: "SATURDAY";
|
|
1132
|
+
}>>>;
|
|
1133
|
+
}, z.core.$strip>], "type">;
|
|
1134
|
+
temporalScheduleId: z.ZodString;
|
|
1135
|
+
runMode: z.ZodEnum<{
|
|
1136
|
+
new_session_per_run: "new_session_per_run";
|
|
1137
|
+
reusable_session: "reusable_session";
|
|
1138
|
+
}>;
|
|
1139
|
+
overlapPolicy: z.ZodEnum<{
|
|
1140
|
+
allow_concurrent: "allow_concurrent";
|
|
1141
|
+
skip: "skip";
|
|
1142
|
+
buffer_one: "buffer_one";
|
|
1143
|
+
}>;
|
|
1144
|
+
agentConfig: z.ZodObject<{
|
|
1145
|
+
prompt: z.ZodString;
|
|
1146
|
+
resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1147
|
+
kind: z.ZodLiteral<"repository">;
|
|
1148
|
+
uri: z.ZodString;
|
|
1149
|
+
ref: z.ZodString;
|
|
1150
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1151
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
1152
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
1153
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
1154
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1155
|
+
kind: z.ZodLiteral<"file">;
|
|
1156
|
+
fileId: z.ZodString;
|
|
1157
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1158
|
+
}, z.core.$strip>], "kind">>>;
|
|
1159
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1160
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1161
|
+
id: z.ZodString;
|
|
1162
|
+
}, z.core.$strip>>>;
|
|
1163
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1164
|
+
model: z.ZodOptional<z.ZodString>;
|
|
1165
|
+
reasoningEffort: z.ZodOptional<z.ZodEnum<{
|
|
1166
|
+
none: "none";
|
|
1167
|
+
minimal: "minimal";
|
|
1168
|
+
low: "low";
|
|
1169
|
+
medium: "medium";
|
|
1170
|
+
high: "high";
|
|
1171
|
+
xhigh: "xhigh";
|
|
1172
|
+
}>>;
|
|
1173
|
+
sandboxBackend: z.ZodOptional<z.ZodEnum<{
|
|
1174
|
+
docker: "docker";
|
|
1175
|
+
modal: "modal";
|
|
1176
|
+
local: "local";
|
|
1177
|
+
none: "none";
|
|
1178
|
+
}>>;
|
|
1179
|
+
goal: z.ZodOptional<z.ZodObject<{
|
|
1180
|
+
text: z.ZodString;
|
|
1181
|
+
successCriteria: z.ZodOptional<z.ZodString>;
|
|
1182
|
+
maxAutoContinuations: z.ZodOptional<z.ZodNumber>;
|
|
1183
|
+
}, z.core.$strip>>;
|
|
1184
|
+
}, z.core.$strip>;
|
|
1185
|
+
reusableSessionId: z.ZodNullable<z.ZodString>;
|
|
1186
|
+
environmentId: z.ZodNullable<z.ZodString>;
|
|
1187
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1188
|
+
createdAt: z.ZodString;
|
|
1189
|
+
updatedAt: z.ZodString;
|
|
1190
|
+
}, z.core.$strip>;
|
|
1191
|
+
type ScheduledTask = z.infer<typeof ScheduledTask>;
|
|
1192
|
+
declare const ScheduledTaskRun: z.ZodObject<{
|
|
1193
|
+
id: z.ZodString;
|
|
1194
|
+
accountId: z.ZodString;
|
|
1195
|
+
workspaceId: z.ZodString;
|
|
1196
|
+
taskId: z.ZodString;
|
|
1197
|
+
status: z.ZodEnum<{
|
|
1198
|
+
queued: "queued";
|
|
1199
|
+
failed: "failed";
|
|
1200
|
+
dispatched: "dispatched";
|
|
1201
|
+
}>;
|
|
1202
|
+
triggerType: z.ZodEnum<{
|
|
1203
|
+
scheduled: "scheduled";
|
|
1204
|
+
manual: "manual";
|
|
1205
|
+
}>;
|
|
1206
|
+
scheduledAt: z.ZodNullable<z.ZodString>;
|
|
1207
|
+
firedAt: z.ZodString;
|
|
1208
|
+
sessionId: z.ZodNullable<z.ZodString>;
|
|
1209
|
+
triggerEventId: z.ZodNullable<z.ZodString>;
|
|
1210
|
+
error: z.ZodNullable<z.ZodString>;
|
|
1211
|
+
createdAt: z.ZodString;
|
|
1212
|
+
updatedAt: z.ZodString;
|
|
1213
|
+
}, z.core.$strip>;
|
|
1214
|
+
type ScheduledTaskRun = z.infer<typeof ScheduledTaskRun>;
|
|
1215
|
+
declare const CreateScheduledTaskRequest: z.ZodObject<{
|
|
1216
|
+
name: z.ZodString;
|
|
1217
|
+
schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1218
|
+
type: z.ZodLiteral<"once">;
|
|
1219
|
+
runAt: z.ZodString;
|
|
1220
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1221
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1222
|
+
type: z.ZodLiteral<"interval">;
|
|
1223
|
+
everySeconds: z.ZodNumber;
|
|
1224
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1225
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1226
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1227
|
+
type: z.ZodLiteral<"calendar">;
|
|
1228
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1229
|
+
hour: z.ZodNumber;
|
|
1230
|
+
minute: z.ZodNumber;
|
|
1231
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1232
|
+
SUNDAY: "SUNDAY";
|
|
1233
|
+
MONDAY: "MONDAY";
|
|
1234
|
+
TUESDAY: "TUESDAY";
|
|
1235
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1236
|
+
THURSDAY: "THURSDAY";
|
|
1237
|
+
FRIDAY: "FRIDAY";
|
|
1238
|
+
SATURDAY: "SATURDAY";
|
|
1239
|
+
}>>>;
|
|
1240
|
+
}, z.core.$strip>], "type">;
|
|
1241
|
+
runMode: z.ZodDefault<z.ZodEnum<{
|
|
1242
|
+
new_session_per_run: "new_session_per_run";
|
|
1243
|
+
reusable_session: "reusable_session";
|
|
1244
|
+
}>>;
|
|
1245
|
+
overlapPolicy: z.ZodDefault<z.ZodEnum<{
|
|
1246
|
+
allow_concurrent: "allow_concurrent";
|
|
1247
|
+
skip: "skip";
|
|
1248
|
+
buffer_one: "buffer_one";
|
|
1249
|
+
}>>;
|
|
1250
|
+
agentConfig: z.ZodObject<{
|
|
1251
|
+
prompt: z.ZodString;
|
|
1252
|
+
resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1253
|
+
kind: z.ZodLiteral<"repository">;
|
|
1254
|
+
uri: z.ZodString;
|
|
1255
|
+
ref: z.ZodString;
|
|
1256
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1257
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
1258
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
1259
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
1260
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1261
|
+
kind: z.ZodLiteral<"file">;
|
|
1262
|
+
fileId: z.ZodString;
|
|
1263
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1264
|
+
}, z.core.$strip>], "kind">>>;
|
|
1265
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1266
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1267
|
+
id: z.ZodString;
|
|
1268
|
+
}, z.core.$strip>>>;
|
|
1269
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1270
|
+
model: z.ZodOptional<z.ZodString>;
|
|
1271
|
+
reasoningEffort: z.ZodOptional<z.ZodEnum<{
|
|
1272
|
+
none: "none";
|
|
1273
|
+
minimal: "minimal";
|
|
1274
|
+
low: "low";
|
|
1275
|
+
medium: "medium";
|
|
1276
|
+
high: "high";
|
|
1277
|
+
xhigh: "xhigh";
|
|
1278
|
+
}>>;
|
|
1279
|
+
sandboxBackend: z.ZodOptional<z.ZodEnum<{
|
|
1280
|
+
docker: "docker";
|
|
1281
|
+
modal: "modal";
|
|
1282
|
+
local: "local";
|
|
1283
|
+
none: "none";
|
|
1284
|
+
}>>;
|
|
1285
|
+
goal: z.ZodOptional<z.ZodObject<{
|
|
1286
|
+
text: z.ZodString;
|
|
1287
|
+
successCriteria: z.ZodOptional<z.ZodString>;
|
|
1288
|
+
maxAutoContinuations: z.ZodOptional<z.ZodNumber>;
|
|
1289
|
+
}, z.core.$strip>>;
|
|
1290
|
+
}, z.core.$strip>;
|
|
1291
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
1292
|
+
active: "active";
|
|
1293
|
+
paused: "paused";
|
|
1294
|
+
}>>;
|
|
1295
|
+
environmentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
1296
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1297
|
+
}, z.core.$strip>;
|
|
1298
|
+
type CreateScheduledTaskRequest = z.infer<typeof CreateScheduledTaskRequest>;
|
|
1299
|
+
declare const UpdateScheduledTaskRequest: z.ZodObject<{
|
|
1300
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1301
|
+
schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1302
|
+
type: z.ZodLiteral<"once">;
|
|
1303
|
+
runAt: z.ZodString;
|
|
1304
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1305
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1306
|
+
type: z.ZodLiteral<"interval">;
|
|
1307
|
+
everySeconds: z.ZodNumber;
|
|
1308
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1309
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1310
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1311
|
+
type: z.ZodLiteral<"calendar">;
|
|
1312
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1313
|
+
hour: z.ZodNumber;
|
|
1314
|
+
minute: z.ZodNumber;
|
|
1315
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1316
|
+
SUNDAY: "SUNDAY";
|
|
1317
|
+
MONDAY: "MONDAY";
|
|
1318
|
+
TUESDAY: "TUESDAY";
|
|
1319
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1320
|
+
THURSDAY: "THURSDAY";
|
|
1321
|
+
FRIDAY: "FRIDAY";
|
|
1322
|
+
SATURDAY: "SATURDAY";
|
|
1323
|
+
}>>>;
|
|
1324
|
+
}, z.core.$strip>], "type">>;
|
|
1325
|
+
runMode: z.ZodOptional<z.ZodEnum<{
|
|
1326
|
+
new_session_per_run: "new_session_per_run";
|
|
1327
|
+
reusable_session: "reusable_session";
|
|
1328
|
+
}>>;
|
|
1329
|
+
overlapPolicy: z.ZodOptional<z.ZodEnum<{
|
|
1330
|
+
allow_concurrent: "allow_concurrent";
|
|
1331
|
+
skip: "skip";
|
|
1332
|
+
buffer_one: "buffer_one";
|
|
1333
|
+
}>>;
|
|
1334
|
+
agentConfig: z.ZodOptional<z.ZodObject<{
|
|
1335
|
+
prompt: z.ZodString;
|
|
1336
|
+
resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1337
|
+
kind: z.ZodLiteral<"repository">;
|
|
1338
|
+
uri: z.ZodString;
|
|
1339
|
+
ref: z.ZodString;
|
|
1340
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1341
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
1342
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
1343
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
1344
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1345
|
+
kind: z.ZodLiteral<"file">;
|
|
1346
|
+
fileId: z.ZodString;
|
|
1347
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
1348
|
+
}, z.core.$strip>], "kind">>>;
|
|
1349
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1350
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1351
|
+
id: z.ZodString;
|
|
1352
|
+
}, z.core.$strip>>>;
|
|
1353
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1354
|
+
model: z.ZodOptional<z.ZodString>;
|
|
1355
|
+
reasoningEffort: z.ZodOptional<z.ZodEnum<{
|
|
1356
|
+
none: "none";
|
|
1357
|
+
minimal: "minimal";
|
|
1358
|
+
low: "low";
|
|
1359
|
+
medium: "medium";
|
|
1360
|
+
high: "high";
|
|
1361
|
+
xhigh: "xhigh";
|
|
1362
|
+
}>>;
|
|
1363
|
+
sandboxBackend: z.ZodOptional<z.ZodEnum<{
|
|
1364
|
+
docker: "docker";
|
|
1365
|
+
modal: "modal";
|
|
1366
|
+
local: "local";
|
|
1367
|
+
none: "none";
|
|
1368
|
+
}>>;
|
|
1369
|
+
goal: z.ZodOptional<z.ZodObject<{
|
|
1370
|
+
text: z.ZodString;
|
|
1371
|
+
successCriteria: z.ZodOptional<z.ZodString>;
|
|
1372
|
+
maxAutoContinuations: z.ZodOptional<z.ZodNumber>;
|
|
1373
|
+
}, z.core.$strip>>;
|
|
1374
|
+
}, z.core.$strip>>;
|
|
1375
|
+
status: z.ZodOptional<z.ZodEnum<{
|
|
1376
|
+
active: "active";
|
|
1377
|
+
paused: "paused";
|
|
1378
|
+
}>>;
|
|
1379
|
+
environmentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
1380
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1381
|
+
}, z.core.$strip>;
|
|
1382
|
+
type UpdateScheduledTaskRequest = z.infer<typeof UpdateScheduledTaskRequest>;
|
|
1383
|
+
/**
|
|
1384
|
+
* Manual-trigger body. `triggerId` is a client-supplied idempotency token: a
|
|
1385
|
+
* retried trigger that reuses the same token charges once and starts one run.
|
|
1386
|
+
* Omitting it makes each call a distinct trigger (the server mints a token).
|
|
1387
|
+
*/
|
|
1388
|
+
declare const TriggerScheduledTaskRequest: z.ZodObject<{
|
|
1389
|
+
triggerId: z.ZodOptional<z.ZodString>;
|
|
1390
|
+
}, z.core.$strip>;
|
|
1391
|
+
type TriggerScheduledTaskRequest = z.infer<typeof TriggerScheduledTaskRequest>;
|
|
1392
|
+
declare const CapabilityPackConnectorAuthModel: z.ZodEnum<{
|
|
1393
|
+
oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
|
|
1394
|
+
oauth2_authorization_code: "oauth2_authorization_code";
|
|
1395
|
+
api_key: "api_key";
|
|
1396
|
+
credential_ref: "credential_ref";
|
|
1397
|
+
}>;
|
|
1398
|
+
type CapabilityPackConnectorAuthModel = z.infer<typeof CapabilityPackConnectorAuthModel>;
|
|
1399
|
+
declare const CapabilityPackConnector: z.ZodObject<{
|
|
1400
|
+
id: z.ZodString;
|
|
1401
|
+
name: z.ZodString;
|
|
1402
|
+
category: z.ZodString;
|
|
1403
|
+
authModel: z.ZodEnum<{
|
|
1404
|
+
oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
|
|
1405
|
+
oauth2_authorization_code: "oauth2_authorization_code";
|
|
1406
|
+
api_key: "api_key";
|
|
1407
|
+
credential_ref: "credential_ref";
|
|
1408
|
+
}>;
|
|
1409
|
+
providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1410
|
+
scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1411
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1412
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1413
|
+
}, z.core.$strip>;
|
|
1414
|
+
type CapabilityPackConnector = z.infer<typeof CapabilityPackConnector>;
|
|
1415
|
+
declare const CapabilityPackKnowledge: z.ZodObject<{
|
|
1416
|
+
type: z.ZodLiteral<"document_base">;
|
|
1417
|
+
id: z.ZodString;
|
|
1418
|
+
name: z.ZodString;
|
|
1419
|
+
description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1420
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1421
|
+
}, z.core.$strip>;
|
|
1422
|
+
type CapabilityPackKnowledge = z.infer<typeof CapabilityPackKnowledge>;
|
|
1423
|
+
declare const CapabilityPackScheduledTaskTemplate: z.ZodObject<{
|
|
1424
|
+
id: z.ZodString;
|
|
1425
|
+
name: z.ZodString;
|
|
1426
|
+
description: z.ZodString;
|
|
1427
|
+
defaultSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1428
|
+
type: z.ZodLiteral<"once">;
|
|
1429
|
+
runAt: z.ZodString;
|
|
1430
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1431
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1432
|
+
type: z.ZodLiteral<"interval">;
|
|
1433
|
+
everySeconds: z.ZodNumber;
|
|
1434
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1435
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1436
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1437
|
+
type: z.ZodLiteral<"calendar">;
|
|
1438
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1439
|
+
hour: z.ZodNumber;
|
|
1440
|
+
minute: z.ZodNumber;
|
|
1441
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1442
|
+
SUNDAY: "SUNDAY";
|
|
1443
|
+
MONDAY: "MONDAY";
|
|
1444
|
+
TUESDAY: "TUESDAY";
|
|
1445
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1446
|
+
THURSDAY: "THURSDAY";
|
|
1447
|
+
FRIDAY: "FRIDAY";
|
|
1448
|
+
SATURDAY: "SATURDAY";
|
|
1449
|
+
}>>>;
|
|
1450
|
+
}, z.core.$strip>], "type">;
|
|
1451
|
+
defaultRunMode: z.ZodDefault<z.ZodEnum<{
|
|
1452
|
+
new_session_per_run: "new_session_per_run";
|
|
1453
|
+
reusable_session: "reusable_session";
|
|
1454
|
+
}>>;
|
|
1455
|
+
defaultOverlapPolicy: z.ZodDefault<z.ZodEnum<{
|
|
1456
|
+
allow_concurrent: "allow_concurrent";
|
|
1457
|
+
skip: "skip";
|
|
1458
|
+
buffer_one: "buffer_one";
|
|
1459
|
+
}>>;
|
|
1460
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
1461
|
+
}, z.core.$strip>;
|
|
1462
|
+
type CapabilityPackScheduledTaskTemplate = z.infer<typeof CapabilityPackScheduledTaskTemplate>;
|
|
1463
|
+
declare const CapabilityPackSkillFile: z.ZodObject<{
|
|
1464
|
+
path: z.ZodString;
|
|
1465
|
+
content: z.ZodString;
|
|
1466
|
+
}, z.core.$strip>;
|
|
1467
|
+
type CapabilityPackSkillFile = z.infer<typeof CapabilityPackSkillFile>;
|
|
1468
|
+
declare const CapabilityPackSkill: z.ZodObject<{
|
|
1469
|
+
name: z.ZodString;
|
|
1470
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1471
|
+
files: z.ZodArray<z.ZodObject<{
|
|
1472
|
+
path: z.ZodString;
|
|
1473
|
+
content: z.ZodString;
|
|
1474
|
+
}, z.core.$strip>>;
|
|
1475
|
+
}, z.core.$strip>;
|
|
1476
|
+
type CapabilityPackSkill = z.infer<typeof CapabilityPackSkill>;
|
|
1477
|
+
declare const CapabilityPack: z.ZodObject<{
|
|
1478
|
+
id: z.ZodString;
|
|
1479
|
+
name: z.ZodString;
|
|
1480
|
+
description: z.ZodString;
|
|
1481
|
+
role: z.ZodString;
|
|
1482
|
+
category: z.ZodString;
|
|
1483
|
+
version: z.ZodString;
|
|
1484
|
+
sandboxImage: z.ZodOptional<z.ZodString>;
|
|
1485
|
+
skills: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1486
|
+
name: z.ZodString;
|
|
1487
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1488
|
+
files: z.ZodArray<z.ZodObject<{
|
|
1489
|
+
path: z.ZodString;
|
|
1490
|
+
content: z.ZodString;
|
|
1491
|
+
}, z.core.$strip>>;
|
|
1492
|
+
}, z.core.$strip>>>;
|
|
1493
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1494
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1495
|
+
id: z.ZodString;
|
|
1496
|
+
}, z.core.$strip>>>;
|
|
1497
|
+
connectors: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1498
|
+
id: z.ZodString;
|
|
1499
|
+
name: z.ZodString;
|
|
1500
|
+
category: z.ZodString;
|
|
1501
|
+
authModel: z.ZodEnum<{
|
|
1502
|
+
oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
|
|
1503
|
+
oauth2_authorization_code: "oauth2_authorization_code";
|
|
1504
|
+
api_key: "api_key";
|
|
1505
|
+
credential_ref: "credential_ref";
|
|
1506
|
+
}>;
|
|
1507
|
+
providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1508
|
+
scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1509
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1510
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1511
|
+
}, z.core.$strip>>>;
|
|
1512
|
+
knowledge: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1513
|
+
type: z.ZodLiteral<"document_base">;
|
|
1514
|
+
id: z.ZodString;
|
|
1515
|
+
name: z.ZodString;
|
|
1516
|
+
description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1517
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1518
|
+
}, z.core.$strip>>>;
|
|
1519
|
+
scheduledTaskTemplates: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1520
|
+
id: z.ZodString;
|
|
1521
|
+
name: z.ZodString;
|
|
1522
|
+
description: z.ZodString;
|
|
1523
|
+
defaultSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1524
|
+
type: z.ZodLiteral<"once">;
|
|
1525
|
+
runAt: z.ZodString;
|
|
1526
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1527
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1528
|
+
type: z.ZodLiteral<"interval">;
|
|
1529
|
+
everySeconds: z.ZodNumber;
|
|
1530
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1531
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1532
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1533
|
+
type: z.ZodLiteral<"calendar">;
|
|
1534
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1535
|
+
hour: z.ZodNumber;
|
|
1536
|
+
minute: z.ZodNumber;
|
|
1537
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1538
|
+
SUNDAY: "SUNDAY";
|
|
1539
|
+
MONDAY: "MONDAY";
|
|
1540
|
+
TUESDAY: "TUESDAY";
|
|
1541
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1542
|
+
THURSDAY: "THURSDAY";
|
|
1543
|
+
FRIDAY: "FRIDAY";
|
|
1544
|
+
SATURDAY: "SATURDAY";
|
|
1545
|
+
}>>>;
|
|
1546
|
+
}, z.core.$strip>], "type">;
|
|
1547
|
+
defaultRunMode: z.ZodDefault<z.ZodEnum<{
|
|
1548
|
+
new_session_per_run: "new_session_per_run";
|
|
1549
|
+
reusable_session: "reusable_session";
|
|
1550
|
+
}>>;
|
|
1551
|
+
defaultOverlapPolicy: z.ZodDefault<z.ZodEnum<{
|
|
1552
|
+
allow_concurrent: "allow_concurrent";
|
|
1553
|
+
skip: "skip";
|
|
1554
|
+
buffer_one: "buffer_one";
|
|
1555
|
+
}>>;
|
|
1556
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
1557
|
+
}, z.core.$strip>>>;
|
|
1558
|
+
environment: z.ZodOptional<z.ZodObject<{
|
|
1559
|
+
description: z.ZodString;
|
|
1560
|
+
requiredVariables: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1561
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1562
|
+
}, z.core.$strip>>;
|
|
1563
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1564
|
+
}, z.core.$strip>;
|
|
1565
|
+
type CapabilityPack = z.infer<typeof CapabilityPack>;
|
|
1566
|
+
declare const RegisterCapabilityPackRequest: z.ZodObject<{
|
|
1567
|
+
id: z.ZodString;
|
|
1568
|
+
name: z.ZodString;
|
|
1569
|
+
description: z.ZodString;
|
|
1570
|
+
role: z.ZodString;
|
|
1571
|
+
category: z.ZodString;
|
|
1572
|
+
version: z.ZodString;
|
|
1573
|
+
sandboxImage: z.ZodOptional<z.ZodString>;
|
|
1574
|
+
skills: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1575
|
+
name: z.ZodString;
|
|
1576
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1577
|
+
files: z.ZodArray<z.ZodObject<{
|
|
1578
|
+
path: z.ZodString;
|
|
1579
|
+
content: z.ZodString;
|
|
1580
|
+
}, z.core.$strip>>;
|
|
1581
|
+
}, z.core.$strip>>>;
|
|
1582
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1583
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1584
|
+
id: z.ZodString;
|
|
1585
|
+
}, z.core.$strip>>>;
|
|
1586
|
+
connectors: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1587
|
+
id: z.ZodString;
|
|
1588
|
+
name: z.ZodString;
|
|
1589
|
+
category: z.ZodString;
|
|
1590
|
+
authModel: z.ZodEnum<{
|
|
1591
|
+
oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
|
|
1592
|
+
oauth2_authorization_code: "oauth2_authorization_code";
|
|
1593
|
+
api_key: "api_key";
|
|
1594
|
+
credential_ref: "credential_ref";
|
|
1595
|
+
}>;
|
|
1596
|
+
providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1597
|
+
scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1598
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1599
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1600
|
+
}, z.core.$strip>>>;
|
|
1601
|
+
knowledge: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1602
|
+
type: z.ZodLiteral<"document_base">;
|
|
1603
|
+
id: z.ZodString;
|
|
1604
|
+
name: z.ZodString;
|
|
1605
|
+
description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1606
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1607
|
+
}, z.core.$strip>>>;
|
|
1608
|
+
scheduledTaskTemplates: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1609
|
+
id: z.ZodString;
|
|
1610
|
+
name: z.ZodString;
|
|
1611
|
+
description: z.ZodString;
|
|
1612
|
+
defaultSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1613
|
+
type: z.ZodLiteral<"once">;
|
|
1614
|
+
runAt: z.ZodString;
|
|
1615
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1616
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1617
|
+
type: z.ZodLiteral<"interval">;
|
|
1618
|
+
everySeconds: z.ZodNumber;
|
|
1619
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1620
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1621
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1622
|
+
type: z.ZodLiteral<"calendar">;
|
|
1623
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1624
|
+
hour: z.ZodNumber;
|
|
1625
|
+
minute: z.ZodNumber;
|
|
1626
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1627
|
+
SUNDAY: "SUNDAY";
|
|
1628
|
+
MONDAY: "MONDAY";
|
|
1629
|
+
TUESDAY: "TUESDAY";
|
|
1630
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1631
|
+
THURSDAY: "THURSDAY";
|
|
1632
|
+
FRIDAY: "FRIDAY";
|
|
1633
|
+
SATURDAY: "SATURDAY";
|
|
1634
|
+
}>>>;
|
|
1635
|
+
}, z.core.$strip>], "type">;
|
|
1636
|
+
defaultRunMode: z.ZodDefault<z.ZodEnum<{
|
|
1637
|
+
new_session_per_run: "new_session_per_run";
|
|
1638
|
+
reusable_session: "reusable_session";
|
|
1639
|
+
}>>;
|
|
1640
|
+
defaultOverlapPolicy: z.ZodDefault<z.ZodEnum<{
|
|
1641
|
+
allow_concurrent: "allow_concurrent";
|
|
1642
|
+
skip: "skip";
|
|
1643
|
+
buffer_one: "buffer_one";
|
|
1644
|
+
}>>;
|
|
1645
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
1646
|
+
}, z.core.$strip>>>;
|
|
1647
|
+
environment: z.ZodOptional<z.ZodObject<{
|
|
1648
|
+
description: z.ZodString;
|
|
1649
|
+
requiredVariables: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1650
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1651
|
+
}, z.core.$strip>>;
|
|
1652
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1653
|
+
}, z.core.$strip>;
|
|
1654
|
+
type RegisterCapabilityPackRequest = z.infer<typeof RegisterCapabilityPackRequest>;
|
|
1655
|
+
declare const WorkspaceRegisteredPack: z.ZodObject<{
|
|
1656
|
+
accountId: z.ZodString;
|
|
1657
|
+
workspaceId: z.ZodString;
|
|
1658
|
+
pack: z.ZodObject<{
|
|
1659
|
+
id: z.ZodString;
|
|
1660
|
+
name: z.ZodString;
|
|
1661
|
+
description: z.ZodString;
|
|
1662
|
+
role: z.ZodString;
|
|
1663
|
+
category: z.ZodString;
|
|
1664
|
+
version: z.ZodString;
|
|
1665
|
+
sandboxImage: z.ZodOptional<z.ZodString>;
|
|
1666
|
+
skills: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1667
|
+
name: z.ZodString;
|
|
1668
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1669
|
+
files: z.ZodArray<z.ZodObject<{
|
|
1670
|
+
path: z.ZodString;
|
|
1671
|
+
content: z.ZodString;
|
|
1672
|
+
}, z.core.$strip>>;
|
|
1673
|
+
}, z.core.$strip>>>;
|
|
1674
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1675
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1676
|
+
id: z.ZodString;
|
|
1677
|
+
}, z.core.$strip>>>;
|
|
1678
|
+
connectors: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1679
|
+
id: z.ZodString;
|
|
1680
|
+
name: z.ZodString;
|
|
1681
|
+
category: z.ZodString;
|
|
1682
|
+
authModel: z.ZodEnum<{
|
|
1683
|
+
oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
|
|
1684
|
+
oauth2_authorization_code: "oauth2_authorization_code";
|
|
1685
|
+
api_key: "api_key";
|
|
1686
|
+
credential_ref: "credential_ref";
|
|
1687
|
+
}>;
|
|
1688
|
+
providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1689
|
+
scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1690
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1691
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1692
|
+
}, z.core.$strip>>>;
|
|
1693
|
+
knowledge: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1694
|
+
type: z.ZodLiteral<"document_base">;
|
|
1695
|
+
id: z.ZodString;
|
|
1696
|
+
name: z.ZodString;
|
|
1697
|
+
description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1698
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1699
|
+
}, z.core.$strip>>>;
|
|
1700
|
+
scheduledTaskTemplates: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1701
|
+
id: z.ZodString;
|
|
1702
|
+
name: z.ZodString;
|
|
1703
|
+
description: z.ZodString;
|
|
1704
|
+
defaultSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1705
|
+
type: z.ZodLiteral<"once">;
|
|
1706
|
+
runAt: z.ZodString;
|
|
1707
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1708
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1709
|
+
type: z.ZodLiteral<"interval">;
|
|
1710
|
+
everySeconds: z.ZodNumber;
|
|
1711
|
+
startAt: z.ZodOptional<z.ZodString>;
|
|
1712
|
+
endAt: z.ZodOptional<z.ZodString>;
|
|
1713
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1714
|
+
type: z.ZodLiteral<"calendar">;
|
|
1715
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1716
|
+
hour: z.ZodNumber;
|
|
1717
|
+
minute: z.ZodNumber;
|
|
1718
|
+
daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1719
|
+
SUNDAY: "SUNDAY";
|
|
1720
|
+
MONDAY: "MONDAY";
|
|
1721
|
+
TUESDAY: "TUESDAY";
|
|
1722
|
+
WEDNESDAY: "WEDNESDAY";
|
|
1723
|
+
THURSDAY: "THURSDAY";
|
|
1724
|
+
FRIDAY: "FRIDAY";
|
|
1725
|
+
SATURDAY: "SATURDAY";
|
|
1726
|
+
}>>>;
|
|
1727
|
+
}, z.core.$strip>], "type">;
|
|
1728
|
+
defaultRunMode: z.ZodDefault<z.ZodEnum<{
|
|
1729
|
+
new_session_per_run: "new_session_per_run";
|
|
1730
|
+
reusable_session: "reusable_session";
|
|
1731
|
+
}>>;
|
|
1732
|
+
defaultOverlapPolicy: z.ZodDefault<z.ZodEnum<{
|
|
1733
|
+
allow_concurrent: "allow_concurrent";
|
|
1734
|
+
skip: "skip";
|
|
1735
|
+
buffer_one: "buffer_one";
|
|
1736
|
+
}>>;
|
|
1737
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
1738
|
+
}, z.core.$strip>>>;
|
|
1739
|
+
environment: z.ZodOptional<z.ZodObject<{
|
|
1740
|
+
description: z.ZodString;
|
|
1741
|
+
requiredVariables: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1742
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
1743
|
+
}, z.core.$strip>>;
|
|
1744
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1745
|
+
}, z.core.$strip>;
|
|
1746
|
+
createdAt: z.ZodString;
|
|
1747
|
+
updatedAt: z.ZodString;
|
|
1748
|
+
}, z.core.$strip>;
|
|
1749
|
+
type WorkspaceRegisteredPack = z.infer<typeof WorkspaceRegisteredPack>;
|
|
1750
|
+
declare const PackInstallationStatus: z.ZodEnum<{
|
|
1751
|
+
disabled: "disabled";
|
|
1752
|
+
active: "active";
|
|
1753
|
+
}>;
|
|
1754
|
+
type PackInstallationStatus = z.infer<typeof PackInstallationStatus>;
|
|
1755
|
+
declare const PackInstallation: z.ZodObject<{
|
|
1756
|
+
id: z.ZodString;
|
|
1757
|
+
accountId: z.ZodString;
|
|
1758
|
+
workspaceId: z.ZodString;
|
|
1759
|
+
packId: z.ZodString;
|
|
1760
|
+
status: z.ZodEnum<{
|
|
1761
|
+
disabled: "disabled";
|
|
1762
|
+
active: "active";
|
|
1763
|
+
}>;
|
|
1764
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1765
|
+
enabledAt: z.ZodString;
|
|
1766
|
+
updatedAt: z.ZodString;
|
|
1767
|
+
}, z.core.$strip>;
|
|
1768
|
+
type PackInstallation = z.infer<typeof PackInstallation>;
|
|
1769
|
+
declare const EnablePackRequest: z.ZodObject<{
|
|
1770
|
+
environmentId: z.ZodOptional<z.ZodString>;
|
|
1771
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1772
|
+
}, z.core.$strip>;
|
|
1773
|
+
type EnablePackRequest = z.infer<typeof EnablePackRequest>;
|
|
1774
|
+
declare const SocialProvider: z.ZodEnum<{
|
|
1775
|
+
custom: "custom";
|
|
1776
|
+
x: "x";
|
|
1777
|
+
linkedin: "linkedin";
|
|
1778
|
+
instagram: "instagram";
|
|
1779
|
+
facebook: "facebook";
|
|
1780
|
+
tiktok: "tiktok";
|
|
1781
|
+
youtube: "youtube";
|
|
1782
|
+
}>;
|
|
1783
|
+
type SocialProvider = z.infer<typeof SocialProvider>;
|
|
1784
|
+
declare const SocialConnectionStatus: z.ZodEnum<{
|
|
1785
|
+
disabled: "disabled";
|
|
1786
|
+
connected: "connected";
|
|
1787
|
+
needs_reauth: "needs_reauth";
|
|
1788
|
+
}>;
|
|
1789
|
+
type SocialConnectionStatus = z.infer<typeof SocialConnectionStatus>;
|
|
1790
|
+
declare const SocialConnection: z.ZodObject<{
|
|
1791
|
+
id: z.ZodString;
|
|
1792
|
+
accountId: z.ZodString;
|
|
1793
|
+
workspaceId: z.ZodString;
|
|
1794
|
+
provider: z.ZodEnum<{
|
|
1795
|
+
custom: "custom";
|
|
1796
|
+
x: "x";
|
|
1797
|
+
linkedin: "linkedin";
|
|
1798
|
+
instagram: "instagram";
|
|
1799
|
+
facebook: "facebook";
|
|
1800
|
+
tiktok: "tiktok";
|
|
1801
|
+
youtube: "youtube";
|
|
1802
|
+
}>;
|
|
1803
|
+
accountHandle: z.ZodString;
|
|
1804
|
+
accountName: z.ZodNullable<z.ZodString>;
|
|
1805
|
+
externalAccountId: z.ZodNullable<z.ZodString>;
|
|
1806
|
+
status: z.ZodEnum<{
|
|
1807
|
+
disabled: "disabled";
|
|
1808
|
+
connected: "connected";
|
|
1809
|
+
needs_reauth: "needs_reauth";
|
|
1810
|
+
}>;
|
|
1811
|
+
scopes: z.ZodArray<z.ZodString>;
|
|
1812
|
+
credentialRef: z.ZodNullable<z.ZodString>;
|
|
1813
|
+
tokenMetadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1814
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1815
|
+
createdAt: z.ZodString;
|
|
1816
|
+
updatedAt: z.ZodString;
|
|
1817
|
+
}, z.core.$strip>;
|
|
1818
|
+
type SocialConnection = z.infer<typeof SocialConnection>;
|
|
1819
|
+
declare const CreateSocialConnectionRequest: z.ZodObject<{
|
|
1820
|
+
provider: z.ZodEnum<{
|
|
1821
|
+
custom: "custom";
|
|
1822
|
+
x: "x";
|
|
1823
|
+
linkedin: "linkedin";
|
|
1824
|
+
instagram: "instagram";
|
|
1825
|
+
facebook: "facebook";
|
|
1826
|
+
tiktok: "tiktok";
|
|
1827
|
+
youtube: "youtube";
|
|
1828
|
+
}>;
|
|
1829
|
+
accountHandle: z.ZodString;
|
|
1830
|
+
accountName: z.ZodOptional<z.ZodString>;
|
|
1831
|
+
externalAccountId: z.ZodOptional<z.ZodString>;
|
|
1832
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
1833
|
+
disabled: "disabled";
|
|
1834
|
+
connected: "connected";
|
|
1835
|
+
needs_reauth: "needs_reauth";
|
|
1836
|
+
}>>;
|
|
1837
|
+
scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1838
|
+
credentialRef: z.ZodOptional<z.ZodString>;
|
|
1839
|
+
tokenMetadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1840
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1841
|
+
}, z.core.$strip>;
|
|
1842
|
+
type CreateSocialConnectionRequest = z.infer<typeof CreateSocialConnectionRequest>;
|
|
1843
|
+
declare const SocialPost: z.ZodObject<{
|
|
1844
|
+
id: z.ZodString;
|
|
1845
|
+
accountId: z.ZodString;
|
|
1846
|
+
workspaceId: z.ZodString;
|
|
1847
|
+
connectionId: z.ZodString;
|
|
1848
|
+
provider: z.ZodEnum<{
|
|
1849
|
+
custom: "custom";
|
|
1850
|
+
x: "x";
|
|
1851
|
+
linkedin: "linkedin";
|
|
1852
|
+
instagram: "instagram";
|
|
1853
|
+
facebook: "facebook";
|
|
1854
|
+
tiktok: "tiktok";
|
|
1855
|
+
youtube: "youtube";
|
|
1856
|
+
}>;
|
|
1857
|
+
externalPostId: z.ZodNullable<z.ZodString>;
|
|
1858
|
+
url: z.ZodNullable<z.ZodString>;
|
|
1859
|
+
authorHandle: z.ZodNullable<z.ZodString>;
|
|
1860
|
+
text: z.ZodString;
|
|
1861
|
+
publishedAt: z.ZodString;
|
|
1862
|
+
metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
|
|
1863
|
+
raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1864
|
+
createdAt: z.ZodString;
|
|
1865
|
+
}, z.core.$strip>;
|
|
1866
|
+
type SocialPost = z.infer<typeof SocialPost>;
|
|
1867
|
+
declare const CreateSocialPostRequest: z.ZodObject<{
|
|
1868
|
+
connectionId: z.ZodString;
|
|
1869
|
+
externalPostId: z.ZodOptional<z.ZodString>;
|
|
1870
|
+
url: z.ZodOptional<z.ZodString>;
|
|
1871
|
+
authorHandle: z.ZodOptional<z.ZodString>;
|
|
1872
|
+
text: z.ZodString;
|
|
1873
|
+
publishedAt: z.ZodString;
|
|
1874
|
+
metrics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
|
|
1875
|
+
raw: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1876
|
+
}, z.core.$strip>;
|
|
1877
|
+
type CreateSocialPostRequest = z.infer<typeof CreateSocialPostRequest>;
|
|
1878
|
+
declare const MarketingDailyAnalysisTaskRequest: z.ZodObject<{
|
|
1879
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1880
|
+
connectionIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1881
|
+
documentBaseIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1882
|
+
timeZone: z.ZodDefault<z.ZodString>;
|
|
1883
|
+
hour: z.ZodDefault<z.ZodNumber>;
|
|
1884
|
+
minute: z.ZodDefault<z.ZodNumber>;
|
|
1885
|
+
promptInstructions: z.ZodOptional<z.ZodString>;
|
|
1886
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
1887
|
+
active: "active";
|
|
1888
|
+
paused: "paused";
|
|
1889
|
+
}>>;
|
|
1890
|
+
runMode: z.ZodDefault<z.ZodEnum<{
|
|
1891
|
+
new_session_per_run: "new_session_per_run";
|
|
1892
|
+
reusable_session: "reusable_session";
|
|
1893
|
+
}>>;
|
|
1894
|
+
overlapPolicy: z.ZodDefault<z.ZodEnum<{
|
|
1895
|
+
allow_concurrent: "allow_concurrent";
|
|
1896
|
+
skip: "skip";
|
|
1897
|
+
buffer_one: "buffer_one";
|
|
1898
|
+
}>>;
|
|
1899
|
+
}, z.core.$strip>;
|
|
1900
|
+
type MarketingDailyAnalysisTaskRequest = z.infer<typeof MarketingDailyAnalysisTaskRequest>;
|
|
1901
|
+
declare const CapabilityKind: z.ZodEnum<{
|
|
1902
|
+
mcp: "mcp";
|
|
1903
|
+
api: "api";
|
|
1904
|
+
pack: "pack";
|
|
1905
|
+
skill: "skill";
|
|
1906
|
+
plugin: "plugin";
|
|
1907
|
+
}>;
|
|
1908
|
+
type CapabilityKind = z.infer<typeof CapabilityKind>;
|
|
1909
|
+
declare const CapabilitySource: z.ZodEnum<{
|
|
1910
|
+
configured: "configured";
|
|
1911
|
+
manual: "manual";
|
|
1912
|
+
built_in: "built_in";
|
|
1913
|
+
public_registry: "public_registry";
|
|
1914
|
+
}>;
|
|
1915
|
+
type CapabilitySource = z.infer<typeof CapabilitySource>;
|
|
1916
|
+
declare const CapabilityInstallationStatus: z.ZodEnum<{
|
|
1917
|
+
disabled: "disabled";
|
|
1918
|
+
active: "active";
|
|
1919
|
+
}>;
|
|
1920
|
+
type CapabilityInstallationStatus = z.infer<typeof CapabilityInstallationStatus>;
|
|
1921
|
+
declare const CapabilityRuntime: z.ZodObject<{
|
|
1922
|
+
available: z.ZodDefault<z.ZodBoolean>;
|
|
1923
|
+
mcpServerId: z.ZodOptional<z.ZodString>;
|
|
1924
|
+
transport: z.ZodOptional<z.ZodString>;
|
|
1925
|
+
notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1926
|
+
}, z.core.$strip>;
|
|
1927
|
+
type CapabilityRuntime = z.infer<typeof CapabilityRuntime>;
|
|
1928
|
+
declare const CapabilityCatalogItem: z.ZodObject<{
|
|
1929
|
+
id: z.ZodString;
|
|
1930
|
+
accountId: z.ZodOptional<z.ZodString>;
|
|
1931
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
1932
|
+
kind: z.ZodEnum<{
|
|
1933
|
+
mcp: "mcp";
|
|
1934
|
+
api: "api";
|
|
1935
|
+
pack: "pack";
|
|
1936
|
+
skill: "skill";
|
|
1937
|
+
plugin: "plugin";
|
|
1938
|
+
}>;
|
|
1939
|
+
source: z.ZodEnum<{
|
|
1940
|
+
configured: "configured";
|
|
1941
|
+
manual: "manual";
|
|
1942
|
+
built_in: "built_in";
|
|
1943
|
+
public_registry: "public_registry";
|
|
1944
|
+
}>;
|
|
1945
|
+
name: z.ZodString;
|
|
1946
|
+
description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1947
|
+
category: z.ZodDefault<z.ZodString>;
|
|
1948
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1949
|
+
homepageUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1950
|
+
endpointUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1951
|
+
installUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1952
|
+
authModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1953
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1954
|
+
kind: z.ZodLiteral<"mcp">;
|
|
1955
|
+
id: z.ZodString;
|
|
1956
|
+
}, z.core.$strip>>>;
|
|
1957
|
+
runtime: z.ZodDefault<z.ZodObject<{
|
|
1958
|
+
available: z.ZodDefault<z.ZodBoolean>;
|
|
1959
|
+
mcpServerId: z.ZodOptional<z.ZodString>;
|
|
1960
|
+
transport: z.ZodOptional<z.ZodString>;
|
|
1961
|
+
notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1962
|
+
}, z.core.$strip>>;
|
|
1963
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
1964
|
+
enabledReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
1965
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1966
|
+
createdAt: z.ZodOptional<z.ZodString>;
|
|
1967
|
+
updatedAt: z.ZodOptional<z.ZodString>;
|
|
1968
|
+
}, z.core.$strip>;
|
|
1969
|
+
type CapabilityCatalogItem = z.infer<typeof CapabilityCatalogItem>;
|
|
1970
|
+
declare const CapabilityInstallation: z.ZodObject<{
|
|
1971
|
+
id: z.ZodString;
|
|
1972
|
+
accountId: z.ZodString;
|
|
1973
|
+
workspaceId: z.ZodString;
|
|
1974
|
+
capabilityId: z.ZodString;
|
|
1975
|
+
kind: z.ZodEnum<{
|
|
1976
|
+
mcp: "mcp";
|
|
1977
|
+
api: "api";
|
|
1978
|
+
pack: "pack";
|
|
1979
|
+
skill: "skill";
|
|
1980
|
+
plugin: "plugin";
|
|
1981
|
+
}>;
|
|
1982
|
+
status: z.ZodEnum<{
|
|
1983
|
+
disabled: "disabled";
|
|
1984
|
+
active: "active";
|
|
1985
|
+
}>;
|
|
1986
|
+
config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1987
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1988
|
+
enabledAt: z.ZodString;
|
|
1989
|
+
updatedAt: z.ZodString;
|
|
1990
|
+
}, z.core.$strip>;
|
|
1991
|
+
type CapabilityInstallation = z.infer<typeof CapabilityInstallation>;
|
|
1992
|
+
declare const CreateCapabilityCatalogItemRequest: z.ZodObject<{
|
|
1993
|
+
id: z.ZodOptional<z.ZodString>;
|
|
1994
|
+
kind: z.ZodEnum<{
|
|
1995
|
+
mcp: "mcp";
|
|
1996
|
+
api: "api";
|
|
1997
|
+
skill: "skill";
|
|
1998
|
+
plugin: "plugin";
|
|
1999
|
+
}>;
|
|
2000
|
+
source: z.ZodDefault<z.ZodEnum<{
|
|
2001
|
+
configured: "configured";
|
|
2002
|
+
manual: "manual";
|
|
2003
|
+
built_in: "built_in";
|
|
2004
|
+
public_registry: "public_registry";
|
|
2005
|
+
}>>;
|
|
2006
|
+
name: z.ZodString;
|
|
2007
|
+
description: z.ZodOptional<z.ZodString>;
|
|
2008
|
+
category: z.ZodDefault<z.ZodString>;
|
|
2009
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
2010
|
+
homepageUrl: z.ZodOptional<z.ZodString>;
|
|
2011
|
+
endpointUrl: z.ZodOptional<z.ZodString>;
|
|
2012
|
+
installUrl: z.ZodOptional<z.ZodString>;
|
|
2013
|
+
authModel: z.ZodOptional<z.ZodString>;
|
|
2014
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2015
|
+
}, z.core.$strip>;
|
|
2016
|
+
type CreateCapabilityCatalogItemRequest = z.infer<typeof CreateCapabilityCatalogItemRequest>;
|
|
2017
|
+
declare const EnableCapabilityRequest: z.ZodObject<{
|
|
2018
|
+
config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2019
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2020
|
+
headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
2021
|
+
environmentId: z.ZodOptional<z.ZodString>;
|
|
2022
|
+
}, z.core.$strip>;
|
|
2023
|
+
type EnableCapabilityRequest = z.infer<typeof EnableCapabilityRequest>;
|
|
2024
|
+
declare const CapabilityCatalogResponse: z.ZodObject<{
|
|
2025
|
+
items: z.ZodArray<z.ZodObject<{
|
|
2026
|
+
id: z.ZodString;
|
|
2027
|
+
accountId: z.ZodOptional<z.ZodString>;
|
|
2028
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
2029
|
+
kind: z.ZodEnum<{
|
|
2030
|
+
mcp: "mcp";
|
|
2031
|
+
api: "api";
|
|
2032
|
+
pack: "pack";
|
|
2033
|
+
skill: "skill";
|
|
2034
|
+
plugin: "plugin";
|
|
2035
|
+
}>;
|
|
2036
|
+
source: z.ZodEnum<{
|
|
2037
|
+
configured: "configured";
|
|
2038
|
+
manual: "manual";
|
|
2039
|
+
built_in: "built_in";
|
|
2040
|
+
public_registry: "public_registry";
|
|
2041
|
+
}>;
|
|
2042
|
+
name: z.ZodString;
|
|
2043
|
+
description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2044
|
+
category: z.ZodDefault<z.ZodString>;
|
|
2045
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
2046
|
+
homepageUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2047
|
+
endpointUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2048
|
+
installUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2049
|
+
authModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2050
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
2051
|
+
kind: z.ZodLiteral<"mcp">;
|
|
2052
|
+
id: z.ZodString;
|
|
2053
|
+
}, z.core.$strip>>>;
|
|
2054
|
+
runtime: z.ZodDefault<z.ZodObject<{
|
|
2055
|
+
available: z.ZodDefault<z.ZodBoolean>;
|
|
2056
|
+
mcpServerId: z.ZodOptional<z.ZodString>;
|
|
2057
|
+
transport: z.ZodOptional<z.ZodString>;
|
|
2058
|
+
notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2059
|
+
}, z.core.$strip>>;
|
|
2060
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
2061
|
+
enabledReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2062
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2063
|
+
createdAt: z.ZodOptional<z.ZodString>;
|
|
2064
|
+
updatedAt: z.ZodOptional<z.ZodString>;
|
|
2065
|
+
}, z.core.$strip>>;
|
|
2066
|
+
installations: z.ZodArray<z.ZodObject<{
|
|
2067
|
+
id: z.ZodString;
|
|
2068
|
+
accountId: z.ZodString;
|
|
2069
|
+
workspaceId: z.ZodString;
|
|
2070
|
+
capabilityId: z.ZodString;
|
|
2071
|
+
kind: z.ZodEnum<{
|
|
2072
|
+
mcp: "mcp";
|
|
2073
|
+
api: "api";
|
|
2074
|
+
pack: "pack";
|
|
2075
|
+
skill: "skill";
|
|
2076
|
+
plugin: "plugin";
|
|
2077
|
+
}>;
|
|
2078
|
+
status: z.ZodEnum<{
|
|
2079
|
+
disabled: "disabled";
|
|
2080
|
+
active: "active";
|
|
2081
|
+
}>;
|
|
2082
|
+
config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
2083
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
2084
|
+
enabledAt: z.ZodString;
|
|
2085
|
+
updatedAt: z.ZodString;
|
|
2086
|
+
}, z.core.$strip>>;
|
|
2087
|
+
}, z.core.$strip>;
|
|
2088
|
+
type CapabilityCatalogResponse = z.infer<typeof CapabilityCatalogResponse>;
|
|
2089
|
+
declare const DiscoverMcpCapabilitiesResponse: z.ZodObject<{
|
|
2090
|
+
items: z.ZodArray<z.ZodObject<{
|
|
2091
|
+
id: z.ZodString;
|
|
2092
|
+
accountId: z.ZodOptional<z.ZodString>;
|
|
2093
|
+
workspaceId: z.ZodOptional<z.ZodString>;
|
|
2094
|
+
kind: z.ZodEnum<{
|
|
2095
|
+
mcp: "mcp";
|
|
2096
|
+
api: "api";
|
|
2097
|
+
pack: "pack";
|
|
2098
|
+
skill: "skill";
|
|
2099
|
+
plugin: "plugin";
|
|
2100
|
+
}>;
|
|
2101
|
+
source: z.ZodEnum<{
|
|
2102
|
+
configured: "configured";
|
|
2103
|
+
manual: "manual";
|
|
2104
|
+
built_in: "built_in";
|
|
2105
|
+
public_registry: "public_registry";
|
|
2106
|
+
}>;
|
|
2107
|
+
name: z.ZodString;
|
|
2108
|
+
description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2109
|
+
category: z.ZodDefault<z.ZodString>;
|
|
2110
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
2111
|
+
homepageUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2112
|
+
endpointUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2113
|
+
installUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2114
|
+
authModel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2115
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
2116
|
+
kind: z.ZodLiteral<"mcp">;
|
|
2117
|
+
id: z.ZodString;
|
|
2118
|
+
}, z.core.$strip>>>;
|
|
2119
|
+
runtime: z.ZodDefault<z.ZodObject<{
|
|
2120
|
+
available: z.ZodDefault<z.ZodBoolean>;
|
|
2121
|
+
mcpServerId: z.ZodOptional<z.ZodString>;
|
|
2122
|
+
transport: z.ZodOptional<z.ZodString>;
|
|
2123
|
+
notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2124
|
+
}, z.core.$strip>>;
|
|
2125
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
2126
|
+
enabledReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
|
|
2127
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2128
|
+
createdAt: z.ZodOptional<z.ZodString>;
|
|
2129
|
+
updatedAt: z.ZodOptional<z.ZodString>;
|
|
2130
|
+
}, z.core.$strip>>;
|
|
2131
|
+
source: z.ZodLiteral<"official_mcp_registry">;
|
|
2132
|
+
sourceUrl: z.ZodString;
|
|
2133
|
+
}, z.core.$strip>;
|
|
2134
|
+
type DiscoverMcpCapabilitiesResponse = z.infer<typeof DiscoverMcpCapabilitiesResponse>;
|
|
2135
|
+
declare const Session: z.ZodObject<{
|
|
2136
|
+
id: z.ZodString;
|
|
2137
|
+
workspaceId: z.ZodString;
|
|
2138
|
+
accountId: z.ZodString;
|
|
2139
|
+
status: z.ZodEnum<{
|
|
2140
|
+
queued: "queued";
|
|
2141
|
+
running: "running";
|
|
2142
|
+
idle: "idle";
|
|
2143
|
+
requires_action: "requires_action";
|
|
2144
|
+
failed: "failed";
|
|
2145
|
+
cancelled: "cancelled";
|
|
2146
|
+
}>;
|
|
2147
|
+
initialMessage: z.ZodString;
|
|
2148
|
+
resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2149
|
+
kind: z.ZodLiteral<"repository">;
|
|
2150
|
+
uri: z.ZodString;
|
|
2151
|
+
ref: z.ZodString;
|
|
2152
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
2153
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
2154
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
2155
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
2156
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2157
|
+
kind: z.ZodLiteral<"file">;
|
|
2158
|
+
fileId: z.ZodString;
|
|
2159
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
2160
|
+
}, z.core.$strip>], "kind">>;
|
|
2161
|
+
tools: z.ZodArray<z.ZodObject<{
|
|
2162
|
+
kind: z.ZodLiteral<"mcp">;
|
|
2163
|
+
id: z.ZodString;
|
|
2164
|
+
}, z.core.$strip>>;
|
|
2165
|
+
metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
2166
|
+
model: z.ZodString;
|
|
2167
|
+
sandboxBackend: z.ZodEnum<{
|
|
2168
|
+
docker: "docker";
|
|
2169
|
+
modal: "modal";
|
|
2170
|
+
local: "local";
|
|
2171
|
+
none: "none";
|
|
2172
|
+
}>;
|
|
2173
|
+
environmentId: z.ZodNullable<z.ZodString>;
|
|
2174
|
+
firstPartyMcpPermissions: z.ZodNullable<z.ZodArray<z.ZodEnum<{
|
|
2175
|
+
"account:read": "account:read";
|
|
2176
|
+
"account:admin": "account:admin";
|
|
2177
|
+
"members:manage": "members:manage";
|
|
2178
|
+
"workspace:create": "workspace:create";
|
|
2179
|
+
"billing:read": "billing:read";
|
|
2180
|
+
"billing:manage": "billing:manage";
|
|
2181
|
+
"workspace:read": "workspace:read";
|
|
2182
|
+
"workspace:admin": "workspace:admin";
|
|
2183
|
+
"sessions:create": "sessions:create";
|
|
2184
|
+
"sessions:read": "sessions:read";
|
|
2185
|
+
"sessions:control": "sessions:control";
|
|
2186
|
+
"files:upload": "files:upload";
|
|
2187
|
+
"files:read": "files:read";
|
|
2188
|
+
"documents:manage": "documents:manage";
|
|
2189
|
+
"documents:search": "documents:search";
|
|
2190
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
2191
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
2192
|
+
"github:manage": "github:manage";
|
|
2193
|
+
"github:use": "github:use";
|
|
2194
|
+
"api_keys:manage": "api_keys:manage";
|
|
2195
|
+
"environments:manage": "environments:manage";
|
|
2196
|
+
"environments:use": "environments:use";
|
|
2197
|
+
"goals:manage": "goals:manage";
|
|
2198
|
+
}>>>;
|
|
2199
|
+
parentSessionId: z.ZodNullable<z.ZodString>;
|
|
2200
|
+
createIdempotencyKey: z.ZodNullable<z.ZodString>;
|
|
2201
|
+
temporalWorkflowId: z.ZodNullable<z.ZodString>;
|
|
2202
|
+
activeTurnId: z.ZodNullable<z.ZodString>;
|
|
2203
|
+
lastInputTokens: z.ZodNullable<z.ZodNumber>;
|
|
2204
|
+
lastSequence: z.ZodNumber;
|
|
2205
|
+
createdAt: z.ZodString;
|
|
2206
|
+
updatedAt: z.ZodString;
|
|
2207
|
+
}, z.core.$strip>;
|
|
2208
|
+
type Session = z.infer<typeof Session>;
|
|
2209
|
+
declare const SessionEventType: z.ZodEnum<{
|
|
2210
|
+
"session.created": "session.created";
|
|
2211
|
+
"session.status.changed": "session.status.changed";
|
|
2212
|
+
"session.requiresAction": "session.requiresAction";
|
|
2213
|
+
"session.context.compacted": "session.context.compacted";
|
|
2214
|
+
"session.context.cleared": "session.context.cleared";
|
|
2215
|
+
"user.message": "user.message";
|
|
2216
|
+
"user.interrupt": "user.interrupt";
|
|
2217
|
+
"user.approvalDecision": "user.approvalDecision";
|
|
2218
|
+
"turn.queued": "turn.queued";
|
|
2219
|
+
"turn.updated": "turn.updated";
|
|
2220
|
+
"turn.started": "turn.started";
|
|
2221
|
+
"turn.completed": "turn.completed";
|
|
2222
|
+
"turn.failed": "turn.failed";
|
|
2223
|
+
"turn.cancelled": "turn.cancelled";
|
|
2224
|
+
"turn.preempted": "turn.preempted";
|
|
2225
|
+
"agent.message.delta": "agent.message.delta";
|
|
2226
|
+
"agent.message.completed": "agent.message.completed";
|
|
2227
|
+
"agent.reasoning.delta": "agent.reasoning.delta";
|
|
2228
|
+
"agent.toolCall.created": "agent.toolCall.created";
|
|
2229
|
+
"agent.toolCall.output": "agent.toolCall.output";
|
|
2230
|
+
"agent.updated": "agent.updated";
|
|
2231
|
+
"sandbox.operation.started": "sandbox.operation.started";
|
|
2232
|
+
"sandbox.operation.completed": "sandbox.operation.completed";
|
|
2233
|
+
"sandbox.operation.failed": "sandbox.operation.failed";
|
|
2234
|
+
"sandbox.command.output.delta": "sandbox.command.output.delta";
|
|
2235
|
+
"artifact.created": "artifact.created";
|
|
2236
|
+
"goal.set": "goal.set";
|
|
2237
|
+
"goal.updated": "goal.updated";
|
|
2238
|
+
"goal.completed": "goal.completed";
|
|
2239
|
+
"goal.paused": "goal.paused";
|
|
2240
|
+
"goal.resumed": "goal.resumed";
|
|
2241
|
+
"goal.continuation": "goal.continuation";
|
|
2242
|
+
}>;
|
|
2243
|
+
type SessionEventType = z.infer<typeof SessionEventType>;
|
|
2244
|
+
declare const SessionEvent: z.ZodObject<{
|
|
2245
|
+
id: z.ZodString;
|
|
2246
|
+
workspaceId: z.ZodString;
|
|
2247
|
+
sessionId: z.ZodString;
|
|
2248
|
+
sequence: z.ZodNumber;
|
|
2249
|
+
type: z.ZodEnum<{
|
|
2250
|
+
"session.created": "session.created";
|
|
2251
|
+
"session.status.changed": "session.status.changed";
|
|
2252
|
+
"session.requiresAction": "session.requiresAction";
|
|
2253
|
+
"session.context.compacted": "session.context.compacted";
|
|
2254
|
+
"session.context.cleared": "session.context.cleared";
|
|
2255
|
+
"user.message": "user.message";
|
|
2256
|
+
"user.interrupt": "user.interrupt";
|
|
2257
|
+
"user.approvalDecision": "user.approvalDecision";
|
|
2258
|
+
"turn.queued": "turn.queued";
|
|
2259
|
+
"turn.updated": "turn.updated";
|
|
2260
|
+
"turn.started": "turn.started";
|
|
2261
|
+
"turn.completed": "turn.completed";
|
|
2262
|
+
"turn.failed": "turn.failed";
|
|
2263
|
+
"turn.cancelled": "turn.cancelled";
|
|
2264
|
+
"turn.preempted": "turn.preempted";
|
|
2265
|
+
"agent.message.delta": "agent.message.delta";
|
|
2266
|
+
"agent.message.completed": "agent.message.completed";
|
|
2267
|
+
"agent.reasoning.delta": "agent.reasoning.delta";
|
|
2268
|
+
"agent.toolCall.created": "agent.toolCall.created";
|
|
2269
|
+
"agent.toolCall.output": "agent.toolCall.output";
|
|
2270
|
+
"agent.updated": "agent.updated";
|
|
2271
|
+
"sandbox.operation.started": "sandbox.operation.started";
|
|
2272
|
+
"sandbox.operation.completed": "sandbox.operation.completed";
|
|
2273
|
+
"sandbox.operation.failed": "sandbox.operation.failed";
|
|
2274
|
+
"sandbox.command.output.delta": "sandbox.command.output.delta";
|
|
2275
|
+
"artifact.created": "artifact.created";
|
|
2276
|
+
"goal.set": "goal.set";
|
|
2277
|
+
"goal.updated": "goal.updated";
|
|
2278
|
+
"goal.completed": "goal.completed";
|
|
2279
|
+
"goal.paused": "goal.paused";
|
|
2280
|
+
"goal.resumed": "goal.resumed";
|
|
2281
|
+
"goal.continuation": "goal.continuation";
|
|
2282
|
+
}>;
|
|
2283
|
+
payload: z.ZodDefault<z.ZodUnknown>;
|
|
2284
|
+
occurredAt: z.ZodString;
|
|
2285
|
+
clientEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2286
|
+
turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2287
|
+
}, z.core.$strip>;
|
|
2288
|
+
type SessionEvent = z.infer<typeof SessionEvent>;
|
|
2289
|
+
declare const CreateSessionRequest: z.ZodObject<{
|
|
2290
|
+
initialMessage: z.ZodString;
|
|
2291
|
+
resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2292
|
+
kind: z.ZodLiteral<"repository">;
|
|
2293
|
+
uri: z.ZodString;
|
|
2294
|
+
ref: z.ZodString;
|
|
2295
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
2296
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
2297
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
2298
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
2299
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2300
|
+
kind: z.ZodLiteral<"file">;
|
|
2301
|
+
fileId: z.ZodString;
|
|
2302
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
2303
|
+
}, z.core.$strip>], "kind">>>;
|
|
2304
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
2305
|
+
kind: z.ZodLiteral<"mcp">;
|
|
2306
|
+
id: z.ZodString;
|
|
2307
|
+
}, z.core.$strip>>>;
|
|
2308
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2309
|
+
model: z.ZodOptional<z.ZodString>;
|
|
2310
|
+
reasoningEffort: z.ZodOptional<z.ZodEnum<{
|
|
2311
|
+
none: "none";
|
|
2312
|
+
minimal: "minimal";
|
|
2313
|
+
low: "low";
|
|
2314
|
+
medium: "medium";
|
|
2315
|
+
high: "high";
|
|
2316
|
+
xhigh: "xhigh";
|
|
2317
|
+
}>>;
|
|
2318
|
+
sandboxBackend: z.ZodOptional<z.ZodEnum<{
|
|
2319
|
+
docker: "docker";
|
|
2320
|
+
modal: "modal";
|
|
2321
|
+
local: "local";
|
|
2322
|
+
none: "none";
|
|
2323
|
+
}>>;
|
|
2324
|
+
environmentId: z.ZodOptional<z.ZodString>;
|
|
2325
|
+
goal: z.ZodOptional<z.ZodObject<{
|
|
2326
|
+
text: z.ZodString;
|
|
2327
|
+
successCriteria: z.ZodOptional<z.ZodString>;
|
|
2328
|
+
maxAutoContinuations: z.ZodOptional<z.ZodNumber>;
|
|
2329
|
+
}, z.core.$strip>>;
|
|
2330
|
+
clientEventId: z.ZodOptional<z.ZodString>;
|
|
2331
|
+
idempotencyKey: z.ZodOptional<z.ZodString>;
|
|
2332
|
+
firstPartyMcpPermissions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
2333
|
+
"account:read": "account:read";
|
|
2334
|
+
"account:admin": "account:admin";
|
|
2335
|
+
"members:manage": "members:manage";
|
|
2336
|
+
"workspace:create": "workspace:create";
|
|
2337
|
+
"billing:read": "billing:read";
|
|
2338
|
+
"billing:manage": "billing:manage";
|
|
2339
|
+
"workspace:read": "workspace:read";
|
|
2340
|
+
"workspace:admin": "workspace:admin";
|
|
2341
|
+
"sessions:create": "sessions:create";
|
|
2342
|
+
"sessions:read": "sessions:read";
|
|
2343
|
+
"sessions:control": "sessions:control";
|
|
2344
|
+
"files:upload": "files:upload";
|
|
2345
|
+
"files:read": "files:read";
|
|
2346
|
+
"documents:manage": "documents:manage";
|
|
2347
|
+
"documents:search": "documents:search";
|
|
2348
|
+
"scheduled_tasks:manage": "scheduled_tasks:manage";
|
|
2349
|
+
"scheduled_tasks:run": "scheduled_tasks:run";
|
|
2350
|
+
"github:manage": "github:manage";
|
|
2351
|
+
"github:use": "github:use";
|
|
2352
|
+
"api_keys:manage": "api_keys:manage";
|
|
2353
|
+
"environments:manage": "environments:manage";
|
|
2354
|
+
"environments:use": "environments:use";
|
|
2355
|
+
"goals:manage": "goals:manage";
|
|
2356
|
+
}>>>;
|
|
2357
|
+
}, z.core.$strip>;
|
|
2358
|
+
type CreateSessionRequest = z.infer<typeof CreateSessionRequest>;
|
|
2359
|
+
declare const ClientSessionEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2360
|
+
type: z.ZodLiteral<"user.message">;
|
|
2361
|
+
clientEventId: z.ZodOptional<z.ZodString>;
|
|
2362
|
+
payload: z.ZodObject<{
|
|
2363
|
+
text: z.ZodString;
|
|
2364
|
+
resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2365
|
+
kind: z.ZodLiteral<"repository">;
|
|
2366
|
+
uri: z.ZodString;
|
|
2367
|
+
ref: z.ZodString;
|
|
2368
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
2369
|
+
subpath: z.ZodOptional<z.ZodString>;
|
|
2370
|
+
githubInstallationId: z.ZodOptional<z.ZodNumber>;
|
|
2371
|
+
githubRepositoryId: z.ZodOptional<z.ZodNumber>;
|
|
2372
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2373
|
+
kind: z.ZodLiteral<"file">;
|
|
2374
|
+
fileId: z.ZodString;
|
|
2375
|
+
mountPath: z.ZodOptional<z.ZodString>;
|
|
2376
|
+
}, z.core.$strip>], "kind">>>;
|
|
2377
|
+
tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
2378
|
+
kind: z.ZodLiteral<"mcp">;
|
|
2379
|
+
id: z.ZodString;
|
|
2380
|
+
}, z.core.$strip>>>;
|
|
2381
|
+
model: z.ZodOptional<z.ZodString>;
|
|
2382
|
+
reasoningEffort: z.ZodOptional<z.ZodEnum<{
|
|
2383
|
+
none: "none";
|
|
2384
|
+
minimal: "minimal";
|
|
2385
|
+
low: "low";
|
|
2386
|
+
medium: "medium";
|
|
2387
|
+
high: "high";
|
|
2388
|
+
xhigh: "xhigh";
|
|
2389
|
+
}>>;
|
|
2390
|
+
}, z.core.$strip>;
|
|
2391
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2392
|
+
type: z.ZodLiteral<"user.interrupt">;
|
|
2393
|
+
clientEventId: z.ZodOptional<z.ZodString>;
|
|
2394
|
+
payload: z.ZodDefault<z.ZodObject<{
|
|
2395
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
2396
|
+
}, z.core.$strip>>;
|
|
2397
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2398
|
+
type: z.ZodLiteral<"user.approvalDecision">;
|
|
2399
|
+
clientEventId: z.ZodOptional<z.ZodString>;
|
|
2400
|
+
payload: z.ZodObject<{
|
|
2401
|
+
approvalId: z.ZodString;
|
|
2402
|
+
decision: z.ZodEnum<{
|
|
2403
|
+
approve: "approve";
|
|
2404
|
+
reject: "reject";
|
|
2405
|
+
}>;
|
|
2406
|
+
message: z.ZodOptional<z.ZodString>;
|
|
2407
|
+
}, z.core.$strip>;
|
|
2408
|
+
}, z.core.$strip>], "type">;
|
|
2409
|
+
type ClientSessionEvent = z.infer<typeof ClientSessionEvent>;
|
|
2410
|
+
declare const SessionBusMessage: z.ZodObject<{
|
|
2411
|
+
workspaceId: z.ZodString;
|
|
2412
|
+
sessionId: z.ZodString;
|
|
2413
|
+
events: z.ZodArray<z.ZodObject<{
|
|
2414
|
+
id: z.ZodString;
|
|
2415
|
+
workspaceId: z.ZodString;
|
|
2416
|
+
sessionId: z.ZodString;
|
|
2417
|
+
sequence: z.ZodNumber;
|
|
2418
|
+
type: z.ZodEnum<{
|
|
2419
|
+
"session.created": "session.created";
|
|
2420
|
+
"session.status.changed": "session.status.changed";
|
|
2421
|
+
"session.requiresAction": "session.requiresAction";
|
|
2422
|
+
"session.context.compacted": "session.context.compacted";
|
|
2423
|
+
"session.context.cleared": "session.context.cleared";
|
|
2424
|
+
"user.message": "user.message";
|
|
2425
|
+
"user.interrupt": "user.interrupt";
|
|
2426
|
+
"user.approvalDecision": "user.approvalDecision";
|
|
2427
|
+
"turn.queued": "turn.queued";
|
|
2428
|
+
"turn.updated": "turn.updated";
|
|
2429
|
+
"turn.started": "turn.started";
|
|
2430
|
+
"turn.completed": "turn.completed";
|
|
2431
|
+
"turn.failed": "turn.failed";
|
|
2432
|
+
"turn.cancelled": "turn.cancelled";
|
|
2433
|
+
"turn.preempted": "turn.preempted";
|
|
2434
|
+
"agent.message.delta": "agent.message.delta";
|
|
2435
|
+
"agent.message.completed": "agent.message.completed";
|
|
2436
|
+
"agent.reasoning.delta": "agent.reasoning.delta";
|
|
2437
|
+
"agent.toolCall.created": "agent.toolCall.created";
|
|
2438
|
+
"agent.toolCall.output": "agent.toolCall.output";
|
|
2439
|
+
"agent.updated": "agent.updated";
|
|
2440
|
+
"sandbox.operation.started": "sandbox.operation.started";
|
|
2441
|
+
"sandbox.operation.completed": "sandbox.operation.completed";
|
|
2442
|
+
"sandbox.operation.failed": "sandbox.operation.failed";
|
|
2443
|
+
"sandbox.command.output.delta": "sandbox.command.output.delta";
|
|
2444
|
+
"artifact.created": "artifact.created";
|
|
2445
|
+
"goal.set": "goal.set";
|
|
2446
|
+
"goal.updated": "goal.updated";
|
|
2447
|
+
"goal.completed": "goal.completed";
|
|
2448
|
+
"goal.paused": "goal.paused";
|
|
2449
|
+
"goal.resumed": "goal.resumed";
|
|
2450
|
+
"goal.continuation": "goal.continuation";
|
|
2451
|
+
}>;
|
|
2452
|
+
payload: z.ZodDefault<z.ZodUnknown>;
|
|
2453
|
+
occurredAt: z.ZodString;
|
|
2454
|
+
clientEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2455
|
+
turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2456
|
+
}, z.core.$strip>>;
|
|
2457
|
+
}, z.core.$strip>;
|
|
2458
|
+
type SessionBusMessage = z.infer<typeof SessionBusMessage>;
|
|
2459
|
+
declare const GitHubAppManifestCreate: z.ZodObject<{
|
|
2460
|
+
appName: z.ZodOptional<z.ZodString>;
|
|
2461
|
+
organization: z.ZodOptional<z.ZodString>;
|
|
2462
|
+
public: z.ZodDefault<z.ZodBoolean>;
|
|
2463
|
+
includeCiPermissions: z.ZodDefault<z.ZodBoolean>;
|
|
2464
|
+
}, z.core.$strip>;
|
|
2465
|
+
type GitHubAppManifestCreate = z.infer<typeof GitHubAppManifestCreate>;
|
|
2466
|
+
declare const GitHubRepository: z.ZodObject<{
|
|
2467
|
+
id: z.ZodNumber;
|
|
2468
|
+
installationId: z.ZodNumber;
|
|
2469
|
+
fullName: z.ZodString;
|
|
2470
|
+
name: z.ZodString;
|
|
2471
|
+
private: z.ZodBoolean;
|
|
2472
|
+
htmlUrl: z.ZodString;
|
|
2473
|
+
cloneUrl: z.ZodString;
|
|
2474
|
+
defaultBranch: z.ZodString;
|
|
2475
|
+
accountLogin: z.ZodString;
|
|
2476
|
+
accountType: z.ZodNullable<z.ZodString>;
|
|
2477
|
+
}, z.core.$strip>;
|
|
2478
|
+
type GitHubRepository = z.infer<typeof GitHubRepository>;
|
|
2479
|
+
declare const ClientAuthConfig: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2480
|
+
mode: z.ZodLiteral<"none">;
|
|
2481
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2482
|
+
mode: z.ZodLiteral<"deploymentKey">;
|
|
2483
|
+
headerName: z.ZodLiteral<"x-opengeni-access-key">;
|
|
2484
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2485
|
+
mode: z.ZodLiteral<"configuredToken">;
|
|
2486
|
+
headerName: z.ZodLiteral<"authorization">;
|
|
2487
|
+
scheme: z.ZodLiteral<"bearer">;
|
|
2488
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2489
|
+
mode: z.ZodLiteral<"managedSession">;
|
|
2490
|
+
session: z.ZodLiteral<"cookie">;
|
|
2491
|
+
}, z.core.$strip>], "mode">;
|
|
2492
|
+
type ClientAuthConfig = z.infer<typeof ClientAuthConfig>;
|
|
2493
|
+
declare const ClientConfig: z.ZodObject<{
|
|
2494
|
+
deploymentRevision: z.ZodString;
|
|
2495
|
+
defaultModel: z.ZodString;
|
|
2496
|
+
allowedModels: z.ZodArray<z.ZodString>;
|
|
2497
|
+
defaultReasoningEffort: z.ZodEnum<{
|
|
2498
|
+
none: "none";
|
|
2499
|
+
minimal: "minimal";
|
|
2500
|
+
low: "low";
|
|
2501
|
+
medium: "medium";
|
|
2502
|
+
high: "high";
|
|
2503
|
+
xhigh: "xhigh";
|
|
2504
|
+
}>;
|
|
2505
|
+
allowedReasoningEfforts: z.ZodArray<z.ZodEnum<{
|
|
2506
|
+
none: "none";
|
|
2507
|
+
minimal: "minimal";
|
|
2508
|
+
low: "low";
|
|
2509
|
+
medium: "medium";
|
|
2510
|
+
high: "high";
|
|
2511
|
+
xhigh: "xhigh";
|
|
2512
|
+
}>>;
|
|
2513
|
+
mcpServers: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
2514
|
+
id: z.ZodString;
|
|
2515
|
+
name: z.ZodString;
|
|
2516
|
+
}, z.core.$strip>>>;
|
|
2517
|
+
fileUploads: z.ZodObject<{
|
|
2518
|
+
enabled: z.ZodBoolean;
|
|
2519
|
+
maxSizeBytes: z.ZodNumber;
|
|
2520
|
+
}, z.core.$strip>;
|
|
2521
|
+
productAccessMode: z.ZodEnum<{
|
|
2522
|
+
local: "local";
|
|
2523
|
+
configured: "configured";
|
|
2524
|
+
managed: "managed";
|
|
2525
|
+
}>;
|
|
2526
|
+
auth: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2527
|
+
mode: z.ZodLiteral<"none">;
|
|
2528
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2529
|
+
mode: z.ZodLiteral<"deploymentKey">;
|
|
2530
|
+
headerName: z.ZodLiteral<"x-opengeni-access-key">;
|
|
2531
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2532
|
+
mode: z.ZodLiteral<"configuredToken">;
|
|
2533
|
+
headerName: z.ZodLiteral<"authorization">;
|
|
2534
|
+
scheme: z.ZodLiteral<"bearer">;
|
|
2535
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2536
|
+
mode: z.ZodLiteral<"managedSession">;
|
|
2537
|
+
session: z.ZodLiteral<"cookie">;
|
|
2538
|
+
}, z.core.$strip>], "mode">>;
|
|
2539
|
+
}, z.core.$strip>;
|
|
2540
|
+
type ClientConfig = z.infer<typeof ClientConfig>;
|
|
2541
|
+
type HealthResponse = {
|
|
2542
|
+
service: string;
|
|
2543
|
+
environment: string;
|
|
2544
|
+
ok: boolean;
|
|
2545
|
+
};
|
|
2546
|
+
|
|
2547
|
+
export { AccessContext, AccessGrant, AccountGrant, AccountRole, AddDocumentRequest, ApiKey, BillingBalance, BillingMode, CLEARED_RUN_STATE_BLOB, CLEARED_RUN_STATE_MARKER, CapabilityCatalogItem, CapabilityCatalogResponse, CapabilityInstallation, CapabilityInstallationStatus, CapabilityKind, CapabilityPack, CapabilityPackConnector, CapabilityPackConnectorAuthModel, CapabilityPackKnowledge, CapabilityPackScheduledTaskTemplate, CapabilityPackSkill, CapabilityPackSkillFile, CapabilityRuntime, CapabilitySource, ClearSessionContextRequest, ClientAuthConfig, ClientConfig, ClientSessionEvent, CompactSessionContextRequest, CompactSessionContextResult, CompleteFileUploadResponse, CreateApiKeyRequest, CreateApiKeyResponse, CreateCapabilityCatalogItemRequest, CreateCheckoutRequest, CreateCheckoutResponse, CreateDocumentBaseRequest, CreateFileUploadRequest, CreateFileUploadResponse, CreateScheduledTaskRequest, CreateSessionRequest, CreateSocialConnectionRequest, CreateSocialPostRequest, CreateWorkspaceEnvironmentRequest, CreateWorkspaceRequest, DelegatedAccessTokenPayload, DiscoverMcpCapabilitiesResponse, Document, DocumentBase, DocumentSearchRequest, DocumentSearchResult, DocumentStatus, EnableCapabilityRequest, EnablePackRequest, EntitlementValue, Entitlements, EntitlementsMode, ErrorCode, ErrorEnvelope, FileAsset, FileDownloadUrlResponse, FileResourceRef, FileStatus, FileUploadStatus, GitHubAppManifestCreate, GitHubRepository, GoalSpec, type HealthResponse, LimitAction, LimitDecision, ManagedAccount, MarketingDailyAnalysisTaskRequest, PackInstallation, PackInstallationStatus, PageInfo, Permission, ProductAccessMode, ReasoningEffort, RegisterCapabilityPackRequest, ReorderSessionTurnsRequest, RepositoryResourceRef, ResourceRef, ResourceRefConflictError, SandboxBackend, ScheduledTask, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, Session, SessionBusMessage, SessionEvent, SessionEventType, SessionGoal, SessionGoalCreatedBy, SessionGoalPausedReason, SessionGoalStatus, SessionStatus, SessionTurn, SessionTurnSource, SessionTurnStatus, SetWorkspaceEnvironmentVariableRequest, SocialConnection, SocialConnectionStatus, SocialPost, SocialProvider, StaticUsageLimits, ToolRef, TriggerScheduledTaskRequest, UpdateScheduledTaskRequest, UpdateSessionGoalRequest, UpdateSessionTurnRequest, UpdateWorkspaceEnvironmentRequest, UpdateWorkspaceRequest, UsageEvent, UsageEventType, UsageLimitsMode, Workspace, WorkspaceEnvironment, WorkspaceEnvironmentVariableMetadata, WorkspaceEnvironmentVariableName, WorkspaceRegisteredPack, isClearedRunStateBlob, mergeResourceRefs, mergeToolRefs, paginated, reasoningEffortForMetadata, resourceIdentityKey, signDelegatedAccessToken, stableJson, verifyDelegatedAccessToken };
|