@trigger.dev/core 3.0.0-beta.44 → 3.0.0-beta.45

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.
Files changed (35) hide show
  1. package/dist/{catalog-Gjy5NtAB.d.mts → catalog-QcLmPVsr.d.mts} +1 -1
  2. package/dist/{catalog-EP9DGAGm.d.ts → catalog-mlNxCacM.d.ts} +1 -1
  3. package/dist/{manager-S98VaLUy.d.mts → common-55Mqj8JP.d.mts} +24 -16
  4. package/dist/{manager-S98VaLUy.d.ts → common-55Mqj8JP.d.ts} +24 -16
  5. package/dist/manager-2AqSY67c.d.mts +18 -0
  6. package/dist/manager-6NRInm7C.d.ts +18 -0
  7. package/dist/{messages-xJbR1Vai.d.mts → messages-EJX0bMsF.d.mts} +140 -0
  8. package/dist/{messages-xJbR1Vai.d.ts → messages-EJX0bMsF.d.ts} +140 -0
  9. package/dist/v3/dev/index.d.mts +2 -1
  10. package/dist/v3/dev/index.d.ts +2 -1
  11. package/dist/v3/index.d.mts +64 -4571
  12. package/dist/v3/index.d.ts +64 -4571
  13. package/dist/v3/index.js +30 -7
  14. package/dist/v3/index.js.map +1 -1
  15. package/dist/v3/index.mjs +30 -8
  16. package/dist/v3/index.mjs.map +1 -1
  17. package/dist/v3/otel/index.js +1 -1
  18. package/dist/v3/otel/index.js.map +1 -1
  19. package/dist/v3/otel/index.mjs +1 -1
  20. package/dist/v3/otel/index.mjs.map +1 -1
  21. package/dist/v3/prod/index.d.mts +3 -2
  22. package/dist/v3/prod/index.d.ts +3 -2
  23. package/dist/v3/schemas/index.d.mts +4633 -0
  24. package/dist/v3/schemas/index.d.ts +4633 -0
  25. package/dist/v3/schemas/index.js +2022 -0
  26. package/dist/v3/schemas/index.js.map +1 -0
  27. package/dist/v3/schemas/index.mjs +1886 -0
  28. package/dist/v3/schemas/index.mjs.map +1 -0
  29. package/dist/v3/workers/index.d.mts +5 -5
  30. package/dist/v3/workers/index.d.ts +5 -5
  31. package/dist/v3/workers/index.js +25 -5
  32. package/dist/v3/workers/index.js.map +1 -1
  33. package/dist/v3/workers/index.mjs +25 -5
  34. package/dist/v3/workers/index.mjs.map +1 -1
  35. package/package.json +9 -1
@@ -2,4582 +2,24 @@ import * as zod from 'zod';
2
2
  import { z } from 'zod';
3
3
  import { CursorPageParams, ApiPromise, CursorPagePromise, OffsetLimitPagePromise } from './zodfetch.js';
4
4
  export { APIHeaders, ApiConnectionError, ApiError, AuthenticationError, BadRequestError, ConflictError, CursorPage, CursorPageResponse, InternalServerError, NotFoundError, OffsetLimitPage, OffsetLimitPageParams, OffsetLimitPageResponse, Page, PageResponse, PermissionDeniedError, RateLimitError, UnprocessableEntityError } from './zodfetch.js';
5
- import { T as TaskRunExecutionResult, B as BatchTaskRunExecutionResult, c as TaskRunError, a as TaskRunContext, R as RuntimeManager } from '../manager-S98VaLUy.js';
6
- export { f as MachineConfig, d as MachineCpu, e as MachineMemory, g as MachinePreset, M as MachinePresetName, m as TaskRun, h as TaskRunBuiltInError, i as TaskRunCustomErrorObject, k as TaskRunErrorCodes, b as TaskRunExecution, o as TaskRunExecutionAttempt, t as TaskRunExecutionBatch, p as TaskRunExecutionEnvironment, q as TaskRunExecutionOrganization, r as TaskRunExecutionProject, s as TaskRunExecutionQueue, u as TaskRunExecutionRetry, n as TaskRunExecutionTask, v as TaskRunExecutionUsage, w as TaskRunFailedExecutionResult, l as TaskRunInternalError, j as TaskRunStringError, x as TaskRunSuccessfulExecutionResult } from '../manager-S98VaLUy.js';
7
- import { C as Clock, b as ClockTime, f as TaskLogger, c as TaskCatalog, a as TaskMetadataWithFunctions, T as TriggerTracer } from '../catalog-EP9DGAGm.js';
8
- export { h as Context, F as FailureFnParams, n as HandleErrorArgs, j as HandleErrorFnParams, H as HandleErrorFunction, k as HandleErrorModificationOptions, m as HandleErrorResult, g as InitFnParams, I as InitOutput, L as LogLevel, M as MiddlewareFnParams, P as ProjectConfig, q as ResolveEnvironmentVariablesFunction, p as ResolveEnvironmentVariablesParams, o as ResolveEnvironmentVariablesResult, R as RunFnParams, S as StartFnParams, i as SuccessFnParams, u as usage } from '../catalog-EP9DGAGm.js';
5
+ import { RunStatus, TriggerTaskRequestBody, BatchTriggerTaskRequestBody, ListRunResponseItem, RescheduleRunRequestBody, CreateScheduleOptions, ListScheduleOptions, UpdateScheduleOptions, CreateEnvironmentVariableRequestBody, UpdateEnvironmentVariableRequestBody, Accessory } from './schemas/index.js';
6
+ export { AttemptStatus, BackgroundWorkerMetadata, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, CreateAuthorizationCodeResponse, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateUploadPayloadUrlResponseBody, DeletedScheduleObject, DeploymentErrorData, EnvironmentVariable, EnvironmentVariableResponseBody, EnvironmentVariableValue, EnvironmentVariables, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequest, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponse, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, ImportEnvironmentVariablesRequestBody, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, ListRunResponse, ListSchedulesResult, OtherSpanEvent, PRIMARY_VARIANT, ReplayRunResponse, RetrieveRunResponse, RunEnvironmentDetails, RunScheduleDetails, ScheduleGenerator, ScheduleObject, ScheduledTaskPayload, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskResource, TimezonesResult, TriggerTaskResponse, Variant, WhoAmIResponse, WhoAmIResponseSchema, isCancellationSpanEvent, isExceptionSpanEvent, stringPatternMatchers } from './schemas/index.js';
7
+ import { T as TaskRunExecutionResult, B as BatchTaskRunExecutionResult, c as TaskRunError, a as TaskRunContext } from '../common-55Mqj8JP.js';
8
+ export { f as MachineConfig, d as MachineCpu, e as MachineMemory, g as MachinePreset, M as MachinePresetName, m as TaskRun, h as TaskRunBuiltInError, i as TaskRunCustomErrorObject, k as TaskRunErrorCodes, b as TaskRunExecution, o as TaskRunExecutionAttempt, t as TaskRunExecutionBatch, p as TaskRunExecutionEnvironment, q as TaskRunExecutionOrganization, r as TaskRunExecutionProject, s as TaskRunExecutionQueue, u as TaskRunExecutionRetry, n as TaskRunExecutionTask, v as TaskRunExecutionUsage, w as TaskRunFailedExecutionResult, l as TaskRunInternalError, j as TaskRunStringError, x as TaskRunSuccessfulExecutionResult } from '../common-55Mqj8JP.js';
9
+ import { C as Clock, b as ClockTime, f as TaskLogger, c as TaskCatalog, a as TaskMetadataWithFunctions, T as TriggerTracer } from '../catalog-mlNxCacM.js';
10
+ export { h as Context, F as FailureFnParams, n as HandleErrorArgs, j as HandleErrorFnParams, H as HandleErrorFunction, k as HandleErrorModificationOptions, m as HandleErrorResult, g as InitFnParams, I as InitOutput, L as LogLevel, M as MiddlewareFnParams, P as ProjectConfig, q as ResolveEnvironmentVariablesFunction, p as ResolveEnvironmentVariablesParams, o as ResolveEnvironmentVariablesResult, R as RunFnParams, S as StartFnParams, i as SuccessFnParams, u as usage } from '../catalog-mlNxCacM.js';
9
11
  import { Attributes, Span } from '@opentelemetry/api';
10
- import { B as BackgroundWorkerProperties } from '../messages-xJbR1Vai.js';
11
- export { c as BackgroundWorkerClientMessages, b as BackgroundWorkerServerMessages, i as ClientToSharedQueueMessages, C as CoordinatorToPlatformMessages, k as CoordinatorToProdWorkerMessages, h as PlatformToCoordinatorMessages, g as PlatformToProviderMessages, a as ProdChildToWorkerMessages, l as ProdWorkerSocketData, P as ProdWorkerToChildMessages, j as ProdWorkerToCoordinatorMessages, f as ProviderToPlatformMessages, S as SharedQueueToClientMessages, T as TaskMetadataFailedToParseData, U as UncaughtExceptionMessage, e as childToWorkerMessages, d as clientWebsocketMessages, s as serverWebsocketMessages, w as workerToChildMessages } from '../messages-xJbR1Vai.js';
12
- import { P as Prettify, T as TaskFileMetadata, a as TaskMetadataWithFilePath, R as RetryOptions } from '../schemas-Sb0sJcEt.js';
13
- export { C as Config, E as EnvironmentType, F as FixedWindowRateLimit, g as PostStartCauses, h as PreStopCauses, d as ProdTaskRunExecution, e as ProdTaskRunExecutionPayload, Q as QueueOptions, f as RateLimitOptions, k as RequireKeys, i as ResolvedConfig, S as SlidingWindowRateLimit, b as TaskMetadata, j as TaskRunExecutionLazyAttemptPayload, c as TaskRunExecutionPayload, W as WaitReason } from '../schemas-Sb0sJcEt.js';
12
+ import { R as RuntimeManager } from '../manager-6NRInm7C.js';
13
+ import { B as BackgroundWorkerProperties } from '../messages-EJX0bMsF.js';
14
+ export { c as BackgroundWorkerClientMessages, b as BackgroundWorkerServerMessages, i as ClientToSharedQueueMessages, C as CoordinatorToPlatformMessages, k as CoordinatorToProdWorkerMessages, h as PlatformToCoordinatorMessages, g as PlatformToProviderMessages, a as ProdChildToWorkerMessages, l as ProdWorkerSocketData, P as ProdWorkerToChildMessages, j as ProdWorkerToCoordinatorMessages, f as ProviderToPlatformMessages, S as SharedQueueToClientMessages, T as TaskMetadataFailedToParseData, U as UncaughtExceptionMessage, e as childToWorkerMessages, d as clientWebsocketMessages, s as serverWebsocketMessages, w as workerToChildMessages } from '../messages-EJX0bMsF.js';
15
+ import { T as TaskFileMetadata, a as TaskMetadataWithFilePath, R as RetryOptions } from '../schemas-Sb0sJcEt.js';
16
+ export { C as Config, E as EnvironmentType, F as FixedWindowRateLimit, g as PostStartCauses, h as PreStopCauses, P as Prettify, d as ProdTaskRunExecution, e as ProdTaskRunExecutionPayload, Q as QueueOptions, f as RateLimitOptions, k as RequireKeys, i as ResolvedConfig, S as SlidingWindowRateLimit, b as TaskMetadata, j as TaskRunExecutionLazyAttemptPayload, c as TaskRunExecutionPayload, W as WaitReason } from '../schemas-Sb0sJcEt.js';
14
17
  export { formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, millisecondsToNanoseconds, nanosecondsToMilliseconds } from './utils/durations.js';
15
18
  export { e as eventFilterMatches } from '../eventFilterMatches-2kHImluE.js';
16
19
  import '@opentelemetry/api-logs';
17
20
  import '@opentelemetry/instrumentation';
18
21
  import 'humanize-duration';
19
22
 
20
- declare const CreateAuthorizationCodeResponseSchema: z.ZodObject<{
21
- url: z.ZodString;
22
- authorizationCode: z.ZodString;
23
- }, "strip", z.ZodTypeAny, {
24
- url: string;
25
- authorizationCode: string;
26
- }, {
27
- url: string;
28
- authorizationCode: string;
29
- }>;
30
- type CreateAuthorizationCodeResponse = z.infer<typeof CreateAuthorizationCodeResponseSchema>;
31
- declare const GetPersonalAccessTokenRequestSchema: z.ZodObject<{
32
- authorizationCode: z.ZodString;
33
- }, "strip", z.ZodTypeAny, {
34
- authorizationCode: string;
35
- }, {
36
- authorizationCode: string;
37
- }>;
38
- type GetPersonalAccessTokenRequest = z.infer<typeof GetPersonalAccessTokenRequestSchema>;
39
- declare const GetPersonalAccessTokenResponseSchema: z.ZodObject<{
40
- token: z.ZodNullable<z.ZodObject<{
41
- token: z.ZodString;
42
- obfuscatedToken: z.ZodString;
43
- }, "strip", z.ZodTypeAny, {
44
- token: string;
45
- obfuscatedToken: string;
46
- }, {
47
- token: string;
48
- obfuscatedToken: string;
49
- }>>;
50
- }, "strip", z.ZodTypeAny, {
51
- token: {
52
- token: string;
53
- obfuscatedToken: string;
54
- } | null;
55
- }, {
56
- token: {
57
- token: string;
58
- obfuscatedToken: string;
59
- } | null;
60
- }>;
61
- type GetPersonalAccessTokenResponse = z.infer<typeof GetPersonalAccessTokenResponseSchema>;
62
-
63
- declare const WhoAmIResponseSchema: z.ZodObject<{
64
- userId: z.ZodString;
65
- email: z.ZodString;
66
- dashboardUrl: z.ZodString;
67
- }, "strip", z.ZodTypeAny, {
68
- userId: string;
69
- email: string;
70
- dashboardUrl: string;
71
- }, {
72
- userId: string;
73
- email: string;
74
- dashboardUrl: string;
75
- }>;
76
- type WhoAmIResponse = z.infer<typeof WhoAmIResponseSchema>;
77
- declare const GetProjectResponseBody: z.ZodObject<{
78
- id: z.ZodString;
79
- externalRef: z.ZodString;
80
- name: z.ZodString;
81
- slug: z.ZodString;
82
- createdAt: z.ZodDate;
83
- organization: z.ZodObject<{
84
- id: z.ZodString;
85
- title: z.ZodString;
86
- slug: z.ZodString;
87
- createdAt: z.ZodDate;
88
- }, "strip", z.ZodTypeAny, {
89
- id: string;
90
- createdAt: Date;
91
- slug: string;
92
- title: string;
93
- }, {
94
- id: string;
95
- createdAt: Date;
96
- slug: string;
97
- title: string;
98
- }>;
99
- }, "strip", z.ZodTypeAny, {
100
- id: string;
101
- createdAt: Date;
102
- name: string;
103
- slug: string;
104
- organization: {
105
- id: string;
106
- createdAt: Date;
107
- slug: string;
108
- title: string;
109
- };
110
- externalRef: string;
111
- }, {
112
- id: string;
113
- createdAt: Date;
114
- name: string;
115
- slug: string;
116
- organization: {
117
- id: string;
118
- createdAt: Date;
119
- slug: string;
120
- title: string;
121
- };
122
- externalRef: string;
123
- }>;
124
- type GetProjectResponseBody = z.infer<typeof GetProjectResponseBody>;
125
- declare const GetProjectsResponseBody: z.ZodArray<z.ZodObject<{
126
- id: z.ZodString;
127
- externalRef: z.ZodString;
128
- name: z.ZodString;
129
- slug: z.ZodString;
130
- createdAt: z.ZodDate;
131
- organization: z.ZodObject<{
132
- id: z.ZodString;
133
- title: z.ZodString;
134
- slug: z.ZodString;
135
- createdAt: z.ZodDate;
136
- }, "strip", z.ZodTypeAny, {
137
- id: string;
138
- createdAt: Date;
139
- slug: string;
140
- title: string;
141
- }, {
142
- id: string;
143
- createdAt: Date;
144
- slug: string;
145
- title: string;
146
- }>;
147
- }, "strip", z.ZodTypeAny, {
148
- id: string;
149
- createdAt: Date;
150
- name: string;
151
- slug: string;
152
- organization: {
153
- id: string;
154
- createdAt: Date;
155
- slug: string;
156
- title: string;
157
- };
158
- externalRef: string;
159
- }, {
160
- id: string;
161
- createdAt: Date;
162
- name: string;
163
- slug: string;
164
- organization: {
165
- id: string;
166
- createdAt: Date;
167
- slug: string;
168
- title: string;
169
- };
170
- externalRef: string;
171
- }>, "many">;
172
- type GetProjectsResponseBody = z.infer<typeof GetProjectsResponseBody>;
173
- declare const GetProjectEnvResponse: z.ZodObject<{
174
- apiKey: z.ZodString;
175
- name: z.ZodString;
176
- apiUrl: z.ZodString;
177
- }, "strip", z.ZodTypeAny, {
178
- name: string;
179
- apiKey: string;
180
- apiUrl: string;
181
- }, {
182
- name: string;
183
- apiKey: string;
184
- apiUrl: string;
185
- }>;
186
- type GetProjectEnvResponse = z.infer<typeof GetProjectEnvResponse>;
187
- declare const CreateBackgroundWorkerRequestBody: z.ZodObject<{
188
- localOnly: z.ZodBoolean;
189
- metadata: z.ZodObject<{
190
- packageVersion: z.ZodString;
191
- contentHash: z.ZodString;
192
- cliPackageVersion: z.ZodOptional<z.ZodString>;
193
- tasks: z.ZodArray<z.ZodObject<{
194
- id: z.ZodString;
195
- filePath: z.ZodString;
196
- exportName: z.ZodString;
197
- queue: z.ZodOptional<z.ZodObject<{
198
- name: z.ZodOptional<z.ZodString>;
199
- concurrencyLimit: z.ZodOptional<z.ZodNumber>;
200
- rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
201
- type: z.ZodLiteral<"fixed-window">;
202
- limit: z.ZodNumber;
203
- window: z.ZodUnion<[z.ZodObject<{
204
- seconds: z.ZodNumber;
205
- }, "strip", z.ZodTypeAny, {
206
- seconds: number;
207
- }, {
208
- seconds: number;
209
- }>, z.ZodObject<{
210
- minutes: z.ZodNumber;
211
- }, "strip", z.ZodTypeAny, {
212
- minutes: number;
213
- }, {
214
- minutes: number;
215
- }>, z.ZodObject<{
216
- hours: z.ZodNumber;
217
- }, "strip", z.ZodTypeAny, {
218
- hours: number;
219
- }, {
220
- hours: number;
221
- }>]>;
222
- }, "strip", z.ZodTypeAny, {
223
- type: "fixed-window";
224
- limit: number;
225
- window: ({
226
- seconds: number;
227
- } | {
228
- minutes: number;
229
- } | {
230
- hours: number;
231
- }) & ({
232
- seconds: number;
233
- } | {
234
- minutes: number;
235
- } | {
236
- hours: number;
237
- } | undefined);
238
- }, {
239
- type: "fixed-window";
240
- limit: number;
241
- window: ({
242
- seconds: number;
243
- } | {
244
- minutes: number;
245
- } | {
246
- hours: number;
247
- }) & ({
248
- seconds: number;
249
- } | {
250
- minutes: number;
251
- } | {
252
- hours: number;
253
- } | undefined);
254
- }>, z.ZodObject<{
255
- type: z.ZodLiteral<"sliding-window">;
256
- limit: z.ZodNumber;
257
- window: z.ZodUnion<[z.ZodObject<{
258
- seconds: z.ZodNumber;
259
- }, "strip", z.ZodTypeAny, {
260
- seconds: number;
261
- }, {
262
- seconds: number;
263
- }>, z.ZodObject<{
264
- minutes: z.ZodNumber;
265
- }, "strip", z.ZodTypeAny, {
266
- minutes: number;
267
- }, {
268
- minutes: number;
269
- }>, z.ZodObject<{
270
- hours: z.ZodNumber;
271
- }, "strip", z.ZodTypeAny, {
272
- hours: number;
273
- }, {
274
- hours: number;
275
- }>]>;
276
- }, "strip", z.ZodTypeAny, {
277
- type: "sliding-window";
278
- limit: number;
279
- window: ({
280
- seconds: number;
281
- } | {
282
- minutes: number;
283
- } | {
284
- hours: number;
285
- }) & ({
286
- seconds: number;
287
- } | {
288
- minutes: number;
289
- } | {
290
- hours: number;
291
- } | undefined);
292
- }, {
293
- type: "sliding-window";
294
- limit: number;
295
- window: ({
296
- seconds: number;
297
- } | {
298
- minutes: number;
299
- } | {
300
- hours: number;
301
- }) & ({
302
- seconds: number;
303
- } | {
304
- minutes: number;
305
- } | {
306
- hours: number;
307
- } | undefined);
308
- }>]>>;
309
- }, "strip", z.ZodTypeAny, {
310
- name?: string | undefined;
311
- concurrencyLimit?: number | undefined;
312
- rateLimit?: {
313
- type: "fixed-window";
314
- limit: number;
315
- window: ({
316
- seconds: number;
317
- } | {
318
- minutes: number;
319
- } | {
320
- hours: number;
321
- }) & ({
322
- seconds: number;
323
- } | {
324
- minutes: number;
325
- } | {
326
- hours: number;
327
- } | undefined);
328
- } | {
329
- type: "sliding-window";
330
- limit: number;
331
- window: ({
332
- seconds: number;
333
- } | {
334
- minutes: number;
335
- } | {
336
- hours: number;
337
- }) & ({
338
- seconds: number;
339
- } | {
340
- minutes: number;
341
- } | {
342
- hours: number;
343
- } | undefined);
344
- } | undefined;
345
- }, {
346
- name?: string | undefined;
347
- concurrencyLimit?: number | undefined;
348
- rateLimit?: {
349
- type: "fixed-window";
350
- limit: number;
351
- window: ({
352
- seconds: number;
353
- } | {
354
- minutes: number;
355
- } | {
356
- hours: number;
357
- }) & ({
358
- seconds: number;
359
- } | {
360
- minutes: number;
361
- } | {
362
- hours: number;
363
- } | undefined);
364
- } | {
365
- type: "sliding-window";
366
- limit: number;
367
- window: ({
368
- seconds: number;
369
- } | {
370
- minutes: number;
371
- } | {
372
- hours: number;
373
- }) & ({
374
- seconds: number;
375
- } | {
376
- minutes: number;
377
- } | {
378
- hours: number;
379
- } | undefined);
380
- } | undefined;
381
- }>>;
382
- retry: z.ZodOptional<z.ZodObject<{
383
- maxAttempts: z.ZodOptional<z.ZodNumber>;
384
- factor: z.ZodOptional<z.ZodNumber>;
385
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
386
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
387
- randomize: z.ZodOptional<z.ZodBoolean>;
388
- }, "strip", z.ZodTypeAny, {
389
- maxAttempts?: number | undefined;
390
- factor?: number | undefined;
391
- minTimeoutInMs?: number | undefined;
392
- maxTimeoutInMs?: number | undefined;
393
- randomize?: boolean | undefined;
394
- }, {
395
- maxAttempts?: number | undefined;
396
- factor?: number | undefined;
397
- minTimeoutInMs?: number | undefined;
398
- maxTimeoutInMs?: number | undefined;
399
- randomize?: boolean | undefined;
400
- }>>;
401
- machine: z.ZodOptional<z.ZodObject<{
402
- cpu: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
403
- memory: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
404
- preset: z.ZodOptional<z.ZodEnum<["micro", "small-1x", "small-2x", "medium-1x", "medium-2x", "large-1x", "large-2x"]>>;
405
- }, "strip", z.ZodTypeAny, {
406
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
407
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
408
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
409
- }, {
410
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
411
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
412
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
413
- }>>;
414
- triggerSource: z.ZodOptional<z.ZodString>;
415
- }, "strip", z.ZodTypeAny, {
416
- id: string;
417
- filePath: string;
418
- exportName: string;
419
- queue?: {
420
- name?: string | undefined;
421
- concurrencyLimit?: number | undefined;
422
- rateLimit?: {
423
- type: "fixed-window";
424
- limit: number;
425
- window: ({
426
- seconds: number;
427
- } | {
428
- minutes: number;
429
- } | {
430
- hours: number;
431
- }) & ({
432
- seconds: number;
433
- } | {
434
- minutes: number;
435
- } | {
436
- hours: number;
437
- } | undefined);
438
- } | {
439
- type: "sliding-window";
440
- limit: number;
441
- window: ({
442
- seconds: number;
443
- } | {
444
- minutes: number;
445
- } | {
446
- hours: number;
447
- }) & ({
448
- seconds: number;
449
- } | {
450
- minutes: number;
451
- } | {
452
- hours: number;
453
- } | undefined);
454
- } | undefined;
455
- } | undefined;
456
- retry?: {
457
- maxAttempts?: number | undefined;
458
- factor?: number | undefined;
459
- minTimeoutInMs?: number | undefined;
460
- maxTimeoutInMs?: number | undefined;
461
- randomize?: boolean | undefined;
462
- } | undefined;
463
- machine?: {
464
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
465
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
466
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
467
- } | undefined;
468
- triggerSource?: string | undefined;
469
- }, {
470
- id: string;
471
- filePath: string;
472
- exportName: string;
473
- queue?: {
474
- name?: string | undefined;
475
- concurrencyLimit?: number | undefined;
476
- rateLimit?: {
477
- type: "fixed-window";
478
- limit: number;
479
- window: ({
480
- seconds: number;
481
- } | {
482
- minutes: number;
483
- } | {
484
- hours: number;
485
- }) & ({
486
- seconds: number;
487
- } | {
488
- minutes: number;
489
- } | {
490
- hours: number;
491
- } | undefined);
492
- } | {
493
- type: "sliding-window";
494
- limit: number;
495
- window: ({
496
- seconds: number;
497
- } | {
498
- minutes: number;
499
- } | {
500
- hours: number;
501
- }) & ({
502
- seconds: number;
503
- } | {
504
- minutes: number;
505
- } | {
506
- hours: number;
507
- } | undefined);
508
- } | undefined;
509
- } | undefined;
510
- retry?: {
511
- maxAttempts?: number | undefined;
512
- factor?: number | undefined;
513
- minTimeoutInMs?: number | undefined;
514
- maxTimeoutInMs?: number | undefined;
515
- randomize?: boolean | undefined;
516
- } | undefined;
517
- machine?: {
518
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
519
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
520
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
521
- } | undefined;
522
- triggerSource?: string | undefined;
523
- }>, "many">;
524
- }, "strip", z.ZodTypeAny, {
525
- packageVersion: string;
526
- contentHash: string;
527
- tasks: {
528
- id: string;
529
- filePath: string;
530
- exportName: string;
531
- queue?: {
532
- name?: string | undefined;
533
- concurrencyLimit?: number | undefined;
534
- rateLimit?: {
535
- type: "fixed-window";
536
- limit: number;
537
- window: ({
538
- seconds: number;
539
- } | {
540
- minutes: number;
541
- } | {
542
- hours: number;
543
- }) & ({
544
- seconds: number;
545
- } | {
546
- minutes: number;
547
- } | {
548
- hours: number;
549
- } | undefined);
550
- } | {
551
- type: "sliding-window";
552
- limit: number;
553
- window: ({
554
- seconds: number;
555
- } | {
556
- minutes: number;
557
- } | {
558
- hours: number;
559
- }) & ({
560
- seconds: number;
561
- } | {
562
- minutes: number;
563
- } | {
564
- hours: number;
565
- } | undefined);
566
- } | undefined;
567
- } | undefined;
568
- retry?: {
569
- maxAttempts?: number | undefined;
570
- factor?: number | undefined;
571
- minTimeoutInMs?: number | undefined;
572
- maxTimeoutInMs?: number | undefined;
573
- randomize?: boolean | undefined;
574
- } | undefined;
575
- machine?: {
576
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
577
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
578
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
579
- } | undefined;
580
- triggerSource?: string | undefined;
581
- }[];
582
- cliPackageVersion?: string | undefined;
583
- }, {
584
- packageVersion: string;
585
- contentHash: string;
586
- tasks: {
587
- id: string;
588
- filePath: string;
589
- exportName: string;
590
- queue?: {
591
- name?: string | undefined;
592
- concurrencyLimit?: number | undefined;
593
- rateLimit?: {
594
- type: "fixed-window";
595
- limit: number;
596
- window: ({
597
- seconds: number;
598
- } | {
599
- minutes: number;
600
- } | {
601
- hours: number;
602
- }) & ({
603
- seconds: number;
604
- } | {
605
- minutes: number;
606
- } | {
607
- hours: number;
608
- } | undefined);
609
- } | {
610
- type: "sliding-window";
611
- limit: number;
612
- window: ({
613
- seconds: number;
614
- } | {
615
- minutes: number;
616
- } | {
617
- hours: number;
618
- }) & ({
619
- seconds: number;
620
- } | {
621
- minutes: number;
622
- } | {
623
- hours: number;
624
- } | undefined);
625
- } | undefined;
626
- } | undefined;
627
- retry?: {
628
- maxAttempts?: number | undefined;
629
- factor?: number | undefined;
630
- minTimeoutInMs?: number | undefined;
631
- maxTimeoutInMs?: number | undefined;
632
- randomize?: boolean | undefined;
633
- } | undefined;
634
- machine?: {
635
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
636
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
637
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
638
- } | undefined;
639
- triggerSource?: string | undefined;
640
- }[];
641
- cliPackageVersion?: string | undefined;
642
- }>;
643
- supportsLazyAttempts: z.ZodOptional<z.ZodBoolean>;
644
- }, "strip", z.ZodTypeAny, {
645
- localOnly: boolean;
646
- metadata: {
647
- packageVersion: string;
648
- contentHash: string;
649
- tasks: {
650
- id: string;
651
- filePath: string;
652
- exportName: string;
653
- queue?: {
654
- name?: string | undefined;
655
- concurrencyLimit?: number | undefined;
656
- rateLimit?: {
657
- type: "fixed-window";
658
- limit: number;
659
- window: ({
660
- seconds: number;
661
- } | {
662
- minutes: number;
663
- } | {
664
- hours: number;
665
- }) & ({
666
- seconds: number;
667
- } | {
668
- minutes: number;
669
- } | {
670
- hours: number;
671
- } | undefined);
672
- } | {
673
- type: "sliding-window";
674
- limit: number;
675
- window: ({
676
- seconds: number;
677
- } | {
678
- minutes: number;
679
- } | {
680
- hours: number;
681
- }) & ({
682
- seconds: number;
683
- } | {
684
- minutes: number;
685
- } | {
686
- hours: number;
687
- } | undefined);
688
- } | undefined;
689
- } | undefined;
690
- retry?: {
691
- maxAttempts?: number | undefined;
692
- factor?: number | undefined;
693
- minTimeoutInMs?: number | undefined;
694
- maxTimeoutInMs?: number | undefined;
695
- randomize?: boolean | undefined;
696
- } | undefined;
697
- machine?: {
698
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
699
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
700
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
701
- } | undefined;
702
- triggerSource?: string | undefined;
703
- }[];
704
- cliPackageVersion?: string | undefined;
705
- };
706
- supportsLazyAttempts?: boolean | undefined;
707
- }, {
708
- localOnly: boolean;
709
- metadata: {
710
- packageVersion: string;
711
- contentHash: string;
712
- tasks: {
713
- id: string;
714
- filePath: string;
715
- exportName: string;
716
- queue?: {
717
- name?: string | undefined;
718
- concurrencyLimit?: number | undefined;
719
- rateLimit?: {
720
- type: "fixed-window";
721
- limit: number;
722
- window: ({
723
- seconds: number;
724
- } | {
725
- minutes: number;
726
- } | {
727
- hours: number;
728
- }) & ({
729
- seconds: number;
730
- } | {
731
- minutes: number;
732
- } | {
733
- hours: number;
734
- } | undefined);
735
- } | {
736
- type: "sliding-window";
737
- limit: number;
738
- window: ({
739
- seconds: number;
740
- } | {
741
- minutes: number;
742
- } | {
743
- hours: number;
744
- }) & ({
745
- seconds: number;
746
- } | {
747
- minutes: number;
748
- } | {
749
- hours: number;
750
- } | undefined);
751
- } | undefined;
752
- } | undefined;
753
- retry?: {
754
- maxAttempts?: number | undefined;
755
- factor?: number | undefined;
756
- minTimeoutInMs?: number | undefined;
757
- maxTimeoutInMs?: number | undefined;
758
- randomize?: boolean | undefined;
759
- } | undefined;
760
- machine?: {
761
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
762
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
763
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
764
- } | undefined;
765
- triggerSource?: string | undefined;
766
- }[];
767
- cliPackageVersion?: string | undefined;
768
- };
769
- supportsLazyAttempts?: boolean | undefined;
770
- }>;
771
- type CreateBackgroundWorkerRequestBody = z.infer<typeof CreateBackgroundWorkerRequestBody>;
772
- declare const CreateBackgroundWorkerResponse: z.ZodObject<{
773
- id: z.ZodString;
774
- version: z.ZodString;
775
- contentHash: z.ZodString;
776
- }, "strip", z.ZodTypeAny, {
777
- id: string;
778
- version: string;
779
- contentHash: string;
780
- }, {
781
- id: string;
782
- version: string;
783
- contentHash: string;
784
- }>;
785
- type CreateBackgroundWorkerResponse = z.infer<typeof CreateBackgroundWorkerResponse>;
786
- declare const TriggerTaskRequestBody: z.ZodObject<{
787
- payload: z.ZodAny;
788
- context: z.ZodAny;
789
- options: z.ZodOptional<z.ZodObject<{
790
- dependentAttempt: z.ZodOptional<z.ZodString>;
791
- dependentBatch: z.ZodOptional<z.ZodString>;
792
- lockToVersion: z.ZodOptional<z.ZodString>;
793
- queue: z.ZodOptional<z.ZodObject<{
794
- name: z.ZodOptional<z.ZodString>;
795
- concurrencyLimit: z.ZodOptional<z.ZodNumber>;
796
- rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
797
- type: z.ZodLiteral<"fixed-window">;
798
- limit: z.ZodNumber;
799
- window: z.ZodUnion<[z.ZodObject<{
800
- seconds: z.ZodNumber;
801
- }, "strip", z.ZodTypeAny, {
802
- seconds: number;
803
- }, {
804
- seconds: number;
805
- }>, z.ZodObject<{
806
- minutes: z.ZodNumber;
807
- }, "strip", z.ZodTypeAny, {
808
- minutes: number;
809
- }, {
810
- minutes: number;
811
- }>, z.ZodObject<{
812
- hours: z.ZodNumber;
813
- }, "strip", z.ZodTypeAny, {
814
- hours: number;
815
- }, {
816
- hours: number;
817
- }>]>;
818
- }, "strip", z.ZodTypeAny, {
819
- type: "fixed-window";
820
- limit: number;
821
- window: ({
822
- seconds: number;
823
- } | {
824
- minutes: number;
825
- } | {
826
- hours: number;
827
- }) & ({
828
- seconds: number;
829
- } | {
830
- minutes: number;
831
- } | {
832
- hours: number;
833
- } | undefined);
834
- }, {
835
- type: "fixed-window";
836
- limit: number;
837
- window: ({
838
- seconds: number;
839
- } | {
840
- minutes: number;
841
- } | {
842
- hours: number;
843
- }) & ({
844
- seconds: number;
845
- } | {
846
- minutes: number;
847
- } | {
848
- hours: number;
849
- } | undefined);
850
- }>, z.ZodObject<{
851
- type: z.ZodLiteral<"sliding-window">;
852
- limit: z.ZodNumber;
853
- window: z.ZodUnion<[z.ZodObject<{
854
- seconds: z.ZodNumber;
855
- }, "strip", z.ZodTypeAny, {
856
- seconds: number;
857
- }, {
858
- seconds: number;
859
- }>, z.ZodObject<{
860
- minutes: z.ZodNumber;
861
- }, "strip", z.ZodTypeAny, {
862
- minutes: number;
863
- }, {
864
- minutes: number;
865
- }>, z.ZodObject<{
866
- hours: z.ZodNumber;
867
- }, "strip", z.ZodTypeAny, {
868
- hours: number;
869
- }, {
870
- hours: number;
871
- }>]>;
872
- }, "strip", z.ZodTypeAny, {
873
- type: "sliding-window";
874
- limit: number;
875
- window: ({
876
- seconds: number;
877
- } | {
878
- minutes: number;
879
- } | {
880
- hours: number;
881
- }) & ({
882
- seconds: number;
883
- } | {
884
- minutes: number;
885
- } | {
886
- hours: number;
887
- } | undefined);
888
- }, {
889
- type: "sliding-window";
890
- limit: number;
891
- window: ({
892
- seconds: number;
893
- } | {
894
- minutes: number;
895
- } | {
896
- hours: number;
897
- }) & ({
898
- seconds: number;
899
- } | {
900
- minutes: number;
901
- } | {
902
- hours: number;
903
- } | undefined);
904
- }>]>>;
905
- }, "strip", z.ZodTypeAny, {
906
- name?: string | undefined;
907
- concurrencyLimit?: number | undefined;
908
- rateLimit?: {
909
- type: "fixed-window";
910
- limit: number;
911
- window: ({
912
- seconds: number;
913
- } | {
914
- minutes: number;
915
- } | {
916
- hours: number;
917
- }) & ({
918
- seconds: number;
919
- } | {
920
- minutes: number;
921
- } | {
922
- hours: number;
923
- } | undefined);
924
- } | {
925
- type: "sliding-window";
926
- limit: number;
927
- window: ({
928
- seconds: number;
929
- } | {
930
- minutes: number;
931
- } | {
932
- hours: number;
933
- }) & ({
934
- seconds: number;
935
- } | {
936
- minutes: number;
937
- } | {
938
- hours: number;
939
- } | undefined);
940
- } | undefined;
941
- }, {
942
- name?: string | undefined;
943
- concurrencyLimit?: number | undefined;
944
- rateLimit?: {
945
- type: "fixed-window";
946
- limit: number;
947
- window: ({
948
- seconds: number;
949
- } | {
950
- minutes: number;
951
- } | {
952
- hours: number;
953
- }) & ({
954
- seconds: number;
955
- } | {
956
- minutes: number;
957
- } | {
958
- hours: number;
959
- } | undefined);
960
- } | {
961
- type: "sliding-window";
962
- limit: number;
963
- window: ({
964
- seconds: number;
965
- } | {
966
- minutes: number;
967
- } | {
968
- hours: number;
969
- }) & ({
970
- seconds: number;
971
- } | {
972
- minutes: number;
973
- } | {
974
- hours: number;
975
- } | undefined);
976
- } | undefined;
977
- }>>;
978
- concurrencyKey: z.ZodOptional<z.ZodString>;
979
- idempotencyKey: z.ZodOptional<z.ZodString>;
980
- test: z.ZodOptional<z.ZodBoolean>;
981
- payloadType: z.ZodOptional<z.ZodString>;
982
- }, "strip", z.ZodTypeAny, {
983
- dependentAttempt?: string | undefined;
984
- dependentBatch?: string | undefined;
985
- lockToVersion?: string | undefined;
986
- queue?: {
987
- name?: string | undefined;
988
- concurrencyLimit?: number | undefined;
989
- rateLimit?: {
990
- type: "fixed-window";
991
- limit: number;
992
- window: ({
993
- seconds: number;
994
- } | {
995
- minutes: number;
996
- } | {
997
- hours: number;
998
- }) & ({
999
- seconds: number;
1000
- } | {
1001
- minutes: number;
1002
- } | {
1003
- hours: number;
1004
- } | undefined);
1005
- } | {
1006
- type: "sliding-window";
1007
- limit: number;
1008
- window: ({
1009
- seconds: number;
1010
- } | {
1011
- minutes: number;
1012
- } | {
1013
- hours: number;
1014
- }) & ({
1015
- seconds: number;
1016
- } | {
1017
- minutes: number;
1018
- } | {
1019
- hours: number;
1020
- } | undefined);
1021
- } | undefined;
1022
- } | undefined;
1023
- concurrencyKey?: string | undefined;
1024
- idempotencyKey?: string | undefined;
1025
- test?: boolean | undefined;
1026
- payloadType?: string | undefined;
1027
- }, {
1028
- dependentAttempt?: string | undefined;
1029
- dependentBatch?: string | undefined;
1030
- lockToVersion?: string | undefined;
1031
- queue?: {
1032
- name?: string | undefined;
1033
- concurrencyLimit?: number | undefined;
1034
- rateLimit?: {
1035
- type: "fixed-window";
1036
- limit: number;
1037
- window: ({
1038
- seconds: number;
1039
- } | {
1040
- minutes: number;
1041
- } | {
1042
- hours: number;
1043
- }) & ({
1044
- seconds: number;
1045
- } | {
1046
- minutes: number;
1047
- } | {
1048
- hours: number;
1049
- } | undefined);
1050
- } | {
1051
- type: "sliding-window";
1052
- limit: number;
1053
- window: ({
1054
- seconds: number;
1055
- } | {
1056
- minutes: number;
1057
- } | {
1058
- hours: number;
1059
- }) & ({
1060
- seconds: number;
1061
- } | {
1062
- minutes: number;
1063
- } | {
1064
- hours: number;
1065
- } | undefined);
1066
- } | undefined;
1067
- } | undefined;
1068
- concurrencyKey?: string | undefined;
1069
- idempotencyKey?: string | undefined;
1070
- test?: boolean | undefined;
1071
- payloadType?: string | undefined;
1072
- }>>;
1073
- }, "strip", z.ZodTypeAny, {
1074
- payload?: any;
1075
- context?: any;
1076
- options?: {
1077
- dependentAttempt?: string | undefined;
1078
- dependentBatch?: string | undefined;
1079
- lockToVersion?: string | undefined;
1080
- queue?: {
1081
- name?: string | undefined;
1082
- concurrencyLimit?: number | undefined;
1083
- rateLimit?: {
1084
- type: "fixed-window";
1085
- limit: number;
1086
- window: ({
1087
- seconds: number;
1088
- } | {
1089
- minutes: number;
1090
- } | {
1091
- hours: number;
1092
- }) & ({
1093
- seconds: number;
1094
- } | {
1095
- minutes: number;
1096
- } | {
1097
- hours: number;
1098
- } | undefined);
1099
- } | {
1100
- type: "sliding-window";
1101
- limit: number;
1102
- window: ({
1103
- seconds: number;
1104
- } | {
1105
- minutes: number;
1106
- } | {
1107
- hours: number;
1108
- }) & ({
1109
- seconds: number;
1110
- } | {
1111
- minutes: number;
1112
- } | {
1113
- hours: number;
1114
- } | undefined);
1115
- } | undefined;
1116
- } | undefined;
1117
- concurrencyKey?: string | undefined;
1118
- idempotencyKey?: string | undefined;
1119
- test?: boolean | undefined;
1120
- payloadType?: string | undefined;
1121
- } | undefined;
1122
- }, {
1123
- payload?: any;
1124
- context?: any;
1125
- options?: {
1126
- dependentAttempt?: string | undefined;
1127
- dependentBatch?: string | undefined;
1128
- lockToVersion?: string | undefined;
1129
- queue?: {
1130
- name?: string | undefined;
1131
- concurrencyLimit?: number | undefined;
1132
- rateLimit?: {
1133
- type: "fixed-window";
1134
- limit: number;
1135
- window: ({
1136
- seconds: number;
1137
- } | {
1138
- minutes: number;
1139
- } | {
1140
- hours: number;
1141
- }) & ({
1142
- seconds: number;
1143
- } | {
1144
- minutes: number;
1145
- } | {
1146
- hours: number;
1147
- } | undefined);
1148
- } | {
1149
- type: "sliding-window";
1150
- limit: number;
1151
- window: ({
1152
- seconds: number;
1153
- } | {
1154
- minutes: number;
1155
- } | {
1156
- hours: number;
1157
- }) & ({
1158
- seconds: number;
1159
- } | {
1160
- minutes: number;
1161
- } | {
1162
- hours: number;
1163
- } | undefined);
1164
- } | undefined;
1165
- } | undefined;
1166
- concurrencyKey?: string | undefined;
1167
- idempotencyKey?: string | undefined;
1168
- test?: boolean | undefined;
1169
- payloadType?: string | undefined;
1170
- } | undefined;
1171
- }>;
1172
- type TriggerTaskRequestBody = z.infer<typeof TriggerTaskRequestBody>;
1173
- declare const TriggerTaskResponse: z.ZodObject<{
1174
- id: z.ZodString;
1175
- }, "strip", z.ZodTypeAny, {
1176
- id: string;
1177
- }, {
1178
- id: string;
1179
- }>;
1180
- type TriggerTaskResponse = z.infer<typeof TriggerTaskResponse>;
1181
- declare const BatchTriggerTaskRequestBody: z.ZodObject<{
1182
- items: z.ZodArray<z.ZodObject<{
1183
- payload: z.ZodAny;
1184
- context: z.ZodAny;
1185
- options: z.ZodOptional<z.ZodObject<{
1186
- dependentAttempt: z.ZodOptional<z.ZodString>;
1187
- dependentBatch: z.ZodOptional<z.ZodString>;
1188
- lockToVersion: z.ZodOptional<z.ZodString>;
1189
- queue: z.ZodOptional<z.ZodObject<{
1190
- name: z.ZodOptional<z.ZodString>;
1191
- concurrencyLimit: z.ZodOptional<z.ZodNumber>;
1192
- rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
1193
- type: z.ZodLiteral<"fixed-window">;
1194
- limit: z.ZodNumber;
1195
- window: z.ZodUnion<[z.ZodObject<{
1196
- seconds: z.ZodNumber;
1197
- }, "strip", z.ZodTypeAny, {
1198
- seconds: number;
1199
- }, {
1200
- seconds: number;
1201
- }>, z.ZodObject<{
1202
- minutes: z.ZodNumber;
1203
- }, "strip", z.ZodTypeAny, {
1204
- minutes: number;
1205
- }, {
1206
- minutes: number;
1207
- }>, z.ZodObject<{
1208
- hours: z.ZodNumber;
1209
- }, "strip", z.ZodTypeAny, {
1210
- hours: number;
1211
- }, {
1212
- hours: number;
1213
- }>]>;
1214
- }, "strip", z.ZodTypeAny, {
1215
- type: "fixed-window";
1216
- limit: number;
1217
- window: ({
1218
- seconds: number;
1219
- } | {
1220
- minutes: number;
1221
- } | {
1222
- hours: number;
1223
- }) & ({
1224
- seconds: number;
1225
- } | {
1226
- minutes: number;
1227
- } | {
1228
- hours: number;
1229
- } | undefined);
1230
- }, {
1231
- type: "fixed-window";
1232
- limit: number;
1233
- window: ({
1234
- seconds: number;
1235
- } | {
1236
- minutes: number;
1237
- } | {
1238
- hours: number;
1239
- }) & ({
1240
- seconds: number;
1241
- } | {
1242
- minutes: number;
1243
- } | {
1244
- hours: number;
1245
- } | undefined);
1246
- }>, z.ZodObject<{
1247
- type: z.ZodLiteral<"sliding-window">;
1248
- limit: z.ZodNumber;
1249
- window: z.ZodUnion<[z.ZodObject<{
1250
- seconds: z.ZodNumber;
1251
- }, "strip", z.ZodTypeAny, {
1252
- seconds: number;
1253
- }, {
1254
- seconds: number;
1255
- }>, z.ZodObject<{
1256
- minutes: z.ZodNumber;
1257
- }, "strip", z.ZodTypeAny, {
1258
- minutes: number;
1259
- }, {
1260
- minutes: number;
1261
- }>, z.ZodObject<{
1262
- hours: z.ZodNumber;
1263
- }, "strip", z.ZodTypeAny, {
1264
- hours: number;
1265
- }, {
1266
- hours: number;
1267
- }>]>;
1268
- }, "strip", z.ZodTypeAny, {
1269
- type: "sliding-window";
1270
- limit: number;
1271
- window: ({
1272
- seconds: number;
1273
- } | {
1274
- minutes: number;
1275
- } | {
1276
- hours: number;
1277
- }) & ({
1278
- seconds: number;
1279
- } | {
1280
- minutes: number;
1281
- } | {
1282
- hours: number;
1283
- } | undefined);
1284
- }, {
1285
- type: "sliding-window";
1286
- limit: number;
1287
- window: ({
1288
- seconds: number;
1289
- } | {
1290
- minutes: number;
1291
- } | {
1292
- hours: number;
1293
- }) & ({
1294
- seconds: number;
1295
- } | {
1296
- minutes: number;
1297
- } | {
1298
- hours: number;
1299
- } | undefined);
1300
- }>]>>;
1301
- }, "strip", z.ZodTypeAny, {
1302
- name?: string | undefined;
1303
- concurrencyLimit?: number | undefined;
1304
- rateLimit?: {
1305
- type: "fixed-window";
1306
- limit: number;
1307
- window: ({
1308
- seconds: number;
1309
- } | {
1310
- minutes: number;
1311
- } | {
1312
- hours: number;
1313
- }) & ({
1314
- seconds: number;
1315
- } | {
1316
- minutes: number;
1317
- } | {
1318
- hours: number;
1319
- } | undefined);
1320
- } | {
1321
- type: "sliding-window";
1322
- limit: number;
1323
- window: ({
1324
- seconds: number;
1325
- } | {
1326
- minutes: number;
1327
- } | {
1328
- hours: number;
1329
- }) & ({
1330
- seconds: number;
1331
- } | {
1332
- minutes: number;
1333
- } | {
1334
- hours: number;
1335
- } | undefined);
1336
- } | undefined;
1337
- }, {
1338
- name?: string | undefined;
1339
- concurrencyLimit?: number | undefined;
1340
- rateLimit?: {
1341
- type: "fixed-window";
1342
- limit: number;
1343
- window: ({
1344
- seconds: number;
1345
- } | {
1346
- minutes: number;
1347
- } | {
1348
- hours: number;
1349
- }) & ({
1350
- seconds: number;
1351
- } | {
1352
- minutes: number;
1353
- } | {
1354
- hours: number;
1355
- } | undefined);
1356
- } | {
1357
- type: "sliding-window";
1358
- limit: number;
1359
- window: ({
1360
- seconds: number;
1361
- } | {
1362
- minutes: number;
1363
- } | {
1364
- hours: number;
1365
- }) & ({
1366
- seconds: number;
1367
- } | {
1368
- minutes: number;
1369
- } | {
1370
- hours: number;
1371
- } | undefined);
1372
- } | undefined;
1373
- }>>;
1374
- concurrencyKey: z.ZodOptional<z.ZodString>;
1375
- idempotencyKey: z.ZodOptional<z.ZodString>;
1376
- test: z.ZodOptional<z.ZodBoolean>;
1377
- payloadType: z.ZodOptional<z.ZodString>;
1378
- }, "strip", z.ZodTypeAny, {
1379
- dependentAttempt?: string | undefined;
1380
- dependentBatch?: string | undefined;
1381
- lockToVersion?: string | undefined;
1382
- queue?: {
1383
- name?: string | undefined;
1384
- concurrencyLimit?: number | undefined;
1385
- rateLimit?: {
1386
- type: "fixed-window";
1387
- limit: number;
1388
- window: ({
1389
- seconds: number;
1390
- } | {
1391
- minutes: number;
1392
- } | {
1393
- hours: number;
1394
- }) & ({
1395
- seconds: number;
1396
- } | {
1397
- minutes: number;
1398
- } | {
1399
- hours: number;
1400
- } | undefined);
1401
- } | {
1402
- type: "sliding-window";
1403
- limit: number;
1404
- window: ({
1405
- seconds: number;
1406
- } | {
1407
- minutes: number;
1408
- } | {
1409
- hours: number;
1410
- }) & ({
1411
- seconds: number;
1412
- } | {
1413
- minutes: number;
1414
- } | {
1415
- hours: number;
1416
- } | undefined);
1417
- } | undefined;
1418
- } | undefined;
1419
- concurrencyKey?: string | undefined;
1420
- idempotencyKey?: string | undefined;
1421
- test?: boolean | undefined;
1422
- payloadType?: string | undefined;
1423
- }, {
1424
- dependentAttempt?: string | undefined;
1425
- dependentBatch?: string | undefined;
1426
- lockToVersion?: string | undefined;
1427
- queue?: {
1428
- name?: string | undefined;
1429
- concurrencyLimit?: number | undefined;
1430
- rateLimit?: {
1431
- type: "fixed-window";
1432
- limit: number;
1433
- window: ({
1434
- seconds: number;
1435
- } | {
1436
- minutes: number;
1437
- } | {
1438
- hours: number;
1439
- }) & ({
1440
- seconds: number;
1441
- } | {
1442
- minutes: number;
1443
- } | {
1444
- hours: number;
1445
- } | undefined);
1446
- } | {
1447
- type: "sliding-window";
1448
- limit: number;
1449
- window: ({
1450
- seconds: number;
1451
- } | {
1452
- minutes: number;
1453
- } | {
1454
- hours: number;
1455
- }) & ({
1456
- seconds: number;
1457
- } | {
1458
- minutes: number;
1459
- } | {
1460
- hours: number;
1461
- } | undefined);
1462
- } | undefined;
1463
- } | undefined;
1464
- concurrencyKey?: string | undefined;
1465
- idempotencyKey?: string | undefined;
1466
- test?: boolean | undefined;
1467
- payloadType?: string | undefined;
1468
- }>>;
1469
- }, "strip", z.ZodTypeAny, {
1470
- payload?: any;
1471
- context?: any;
1472
- options?: {
1473
- dependentAttempt?: string | undefined;
1474
- dependentBatch?: string | undefined;
1475
- lockToVersion?: string | undefined;
1476
- queue?: {
1477
- name?: string | undefined;
1478
- concurrencyLimit?: number | undefined;
1479
- rateLimit?: {
1480
- type: "fixed-window";
1481
- limit: number;
1482
- window: ({
1483
- seconds: number;
1484
- } | {
1485
- minutes: number;
1486
- } | {
1487
- hours: number;
1488
- }) & ({
1489
- seconds: number;
1490
- } | {
1491
- minutes: number;
1492
- } | {
1493
- hours: number;
1494
- } | undefined);
1495
- } | {
1496
- type: "sliding-window";
1497
- limit: number;
1498
- window: ({
1499
- seconds: number;
1500
- } | {
1501
- minutes: number;
1502
- } | {
1503
- hours: number;
1504
- }) & ({
1505
- seconds: number;
1506
- } | {
1507
- minutes: number;
1508
- } | {
1509
- hours: number;
1510
- } | undefined);
1511
- } | undefined;
1512
- } | undefined;
1513
- concurrencyKey?: string | undefined;
1514
- idempotencyKey?: string | undefined;
1515
- test?: boolean | undefined;
1516
- payloadType?: string | undefined;
1517
- } | undefined;
1518
- }, {
1519
- payload?: any;
1520
- context?: any;
1521
- options?: {
1522
- dependentAttempt?: string | undefined;
1523
- dependentBatch?: string | undefined;
1524
- lockToVersion?: string | undefined;
1525
- queue?: {
1526
- name?: string | undefined;
1527
- concurrencyLimit?: number | undefined;
1528
- rateLimit?: {
1529
- type: "fixed-window";
1530
- limit: number;
1531
- window: ({
1532
- seconds: number;
1533
- } | {
1534
- minutes: number;
1535
- } | {
1536
- hours: number;
1537
- }) & ({
1538
- seconds: number;
1539
- } | {
1540
- minutes: number;
1541
- } | {
1542
- hours: number;
1543
- } | undefined);
1544
- } | {
1545
- type: "sliding-window";
1546
- limit: number;
1547
- window: ({
1548
- seconds: number;
1549
- } | {
1550
- minutes: number;
1551
- } | {
1552
- hours: number;
1553
- }) & ({
1554
- seconds: number;
1555
- } | {
1556
- minutes: number;
1557
- } | {
1558
- hours: number;
1559
- } | undefined);
1560
- } | undefined;
1561
- } | undefined;
1562
- concurrencyKey?: string | undefined;
1563
- idempotencyKey?: string | undefined;
1564
- test?: boolean | undefined;
1565
- payloadType?: string | undefined;
1566
- } | undefined;
1567
- }>, "many">;
1568
- dependentAttempt: z.ZodOptional<z.ZodString>;
1569
- }, "strip", z.ZodTypeAny, {
1570
- items: {
1571
- payload?: any;
1572
- context?: any;
1573
- options?: {
1574
- dependentAttempt?: string | undefined;
1575
- dependentBatch?: string | undefined;
1576
- lockToVersion?: string | undefined;
1577
- queue?: {
1578
- name?: string | undefined;
1579
- concurrencyLimit?: number | undefined;
1580
- rateLimit?: {
1581
- type: "fixed-window";
1582
- limit: number;
1583
- window: ({
1584
- seconds: number;
1585
- } | {
1586
- minutes: number;
1587
- } | {
1588
- hours: number;
1589
- }) & ({
1590
- seconds: number;
1591
- } | {
1592
- minutes: number;
1593
- } | {
1594
- hours: number;
1595
- } | undefined);
1596
- } | {
1597
- type: "sliding-window";
1598
- limit: number;
1599
- window: ({
1600
- seconds: number;
1601
- } | {
1602
- minutes: number;
1603
- } | {
1604
- hours: number;
1605
- }) & ({
1606
- seconds: number;
1607
- } | {
1608
- minutes: number;
1609
- } | {
1610
- hours: number;
1611
- } | undefined);
1612
- } | undefined;
1613
- } | undefined;
1614
- concurrencyKey?: string | undefined;
1615
- idempotencyKey?: string | undefined;
1616
- test?: boolean | undefined;
1617
- payloadType?: string | undefined;
1618
- } | undefined;
1619
- }[];
1620
- dependentAttempt?: string | undefined;
1621
- }, {
1622
- items: {
1623
- payload?: any;
1624
- context?: any;
1625
- options?: {
1626
- dependentAttempt?: string | undefined;
1627
- dependentBatch?: string | undefined;
1628
- lockToVersion?: string | undefined;
1629
- queue?: {
1630
- name?: string | undefined;
1631
- concurrencyLimit?: number | undefined;
1632
- rateLimit?: {
1633
- type: "fixed-window";
1634
- limit: number;
1635
- window: ({
1636
- seconds: number;
1637
- } | {
1638
- minutes: number;
1639
- } | {
1640
- hours: number;
1641
- }) & ({
1642
- seconds: number;
1643
- } | {
1644
- minutes: number;
1645
- } | {
1646
- hours: number;
1647
- } | undefined);
1648
- } | {
1649
- type: "sliding-window";
1650
- limit: number;
1651
- window: ({
1652
- seconds: number;
1653
- } | {
1654
- minutes: number;
1655
- } | {
1656
- hours: number;
1657
- }) & ({
1658
- seconds: number;
1659
- } | {
1660
- minutes: number;
1661
- } | {
1662
- hours: number;
1663
- } | undefined);
1664
- } | undefined;
1665
- } | undefined;
1666
- concurrencyKey?: string | undefined;
1667
- idempotencyKey?: string | undefined;
1668
- test?: boolean | undefined;
1669
- payloadType?: string | undefined;
1670
- } | undefined;
1671
- }[];
1672
- dependentAttempt?: string | undefined;
1673
- }>;
1674
- type BatchTriggerTaskRequestBody = z.infer<typeof BatchTriggerTaskRequestBody>;
1675
- declare const BatchTriggerTaskResponse: z.ZodObject<{
1676
- batchId: z.ZodString;
1677
- runs: z.ZodArray<z.ZodString, "many">;
1678
- }, "strip", z.ZodTypeAny, {
1679
- batchId: string;
1680
- runs: string[];
1681
- }, {
1682
- batchId: string;
1683
- runs: string[];
1684
- }>;
1685
- type BatchTriggerTaskResponse = z.infer<typeof BatchTriggerTaskResponse>;
1686
- declare const GetBatchResponseBody: z.ZodObject<{
1687
- id: z.ZodString;
1688
- items: z.ZodArray<z.ZodObject<{
1689
- id: z.ZodString;
1690
- taskRunId: z.ZodString;
1691
- status: z.ZodEnum<["PENDING", "CANCELED", "COMPLETED", "FAILED"]>;
1692
- }, "strip", z.ZodTypeAny, {
1693
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
1694
- id: string;
1695
- taskRunId: string;
1696
- }, {
1697
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
1698
- id: string;
1699
- taskRunId: string;
1700
- }>, "many">;
1701
- }, "strip", z.ZodTypeAny, {
1702
- id: string;
1703
- items: {
1704
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
1705
- id: string;
1706
- taskRunId: string;
1707
- }[];
1708
- }, {
1709
- id: string;
1710
- items: {
1711
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
1712
- id: string;
1713
- taskRunId: string;
1714
- }[];
1715
- }>;
1716
- type GetBatchResponseBody = z.infer<typeof GetBatchResponseBody>;
1717
- declare const GetEnvironmentVariablesResponseBody: z.ZodObject<{
1718
- variables: z.ZodRecord<z.ZodString, z.ZodString>;
1719
- }, "strip", z.ZodTypeAny, {
1720
- variables: Record<string, string>;
1721
- }, {
1722
- variables: Record<string, string>;
1723
- }>;
1724
- type GetEnvironmentVariablesResponseBody = z.infer<typeof GetEnvironmentVariablesResponseBody>;
1725
- declare const StartDeploymentIndexingRequestBody: z.ZodObject<{
1726
- imageReference: z.ZodString;
1727
- selfHosted: z.ZodOptional<z.ZodBoolean>;
1728
- }, "strip", z.ZodTypeAny, {
1729
- imageReference: string;
1730
- selfHosted?: boolean | undefined;
1731
- }, {
1732
- imageReference: string;
1733
- selfHosted?: boolean | undefined;
1734
- }>;
1735
- type StartDeploymentIndexingRequestBody = z.infer<typeof StartDeploymentIndexingRequestBody>;
1736
- declare const StartDeploymentIndexingResponseBody: z.ZodObject<{
1737
- id: z.ZodString;
1738
- contentHash: z.ZodString;
1739
- }, "strip", z.ZodTypeAny, {
1740
- id: string;
1741
- contentHash: string;
1742
- }, {
1743
- id: string;
1744
- contentHash: string;
1745
- }>;
1746
- type StartDeploymentIndexingResponseBody = z.infer<typeof StartDeploymentIndexingResponseBody>;
1747
- declare const ExternalBuildData: z.ZodObject<{
1748
- buildId: z.ZodString;
1749
- buildToken: z.ZodString;
1750
- projectId: z.ZodString;
1751
- }, "strip", z.ZodTypeAny, {
1752
- buildId: string;
1753
- buildToken: string;
1754
- projectId: string;
1755
- }, {
1756
- buildId: string;
1757
- buildToken: string;
1758
- projectId: string;
1759
- }>;
1760
- type ExternalBuildData = z.infer<typeof ExternalBuildData>;
1761
- declare const InitializeDeploymentResponseBody: z.ZodObject<{
1762
- id: z.ZodString;
1763
- contentHash: z.ZodString;
1764
- shortCode: z.ZodString;
1765
- version: z.ZodString;
1766
- imageTag: z.ZodString;
1767
- externalBuildData: z.ZodNullable<z.ZodOptional<z.ZodObject<{
1768
- buildId: z.ZodString;
1769
- buildToken: z.ZodString;
1770
- projectId: z.ZodString;
1771
- }, "strip", z.ZodTypeAny, {
1772
- buildId: string;
1773
- buildToken: string;
1774
- projectId: string;
1775
- }, {
1776
- buildId: string;
1777
- buildToken: string;
1778
- projectId: string;
1779
- }>>>;
1780
- registryHost: z.ZodOptional<z.ZodString>;
1781
- }, "strip", z.ZodTypeAny, {
1782
- id: string;
1783
- version: string;
1784
- contentHash: string;
1785
- imageTag: string;
1786
- shortCode: string;
1787
- externalBuildData?: {
1788
- buildId: string;
1789
- buildToken: string;
1790
- projectId: string;
1791
- } | null | undefined;
1792
- registryHost?: string | undefined;
1793
- }, {
1794
- id: string;
1795
- version: string;
1796
- contentHash: string;
1797
- imageTag: string;
1798
- shortCode: string;
1799
- externalBuildData?: {
1800
- buildId: string;
1801
- buildToken: string;
1802
- projectId: string;
1803
- } | null | undefined;
1804
- registryHost?: string | undefined;
1805
- }>;
1806
- type InitializeDeploymentResponseBody = z.infer<typeof InitializeDeploymentResponseBody>;
1807
- declare const InitializeDeploymentRequestBody: z.ZodObject<{
1808
- contentHash: z.ZodString;
1809
- userId: z.ZodOptional<z.ZodString>;
1810
- }, "strip", z.ZodTypeAny, {
1811
- contentHash: string;
1812
- userId?: string | undefined;
1813
- }, {
1814
- contentHash: string;
1815
- userId?: string | undefined;
1816
- }>;
1817
- type InitializeDeploymentRequestBody = z.infer<typeof InitializeDeploymentRequestBody>;
1818
- declare const DeploymentErrorData: z.ZodObject<{
1819
- name: z.ZodString;
1820
- message: z.ZodString;
1821
- stack: z.ZodOptional<z.ZodString>;
1822
- stderr: z.ZodOptional<z.ZodString>;
1823
- }, "strip", z.ZodTypeAny, {
1824
- message: string;
1825
- name: string;
1826
- stack?: string | undefined;
1827
- stderr?: string | undefined;
1828
- }, {
1829
- message: string;
1830
- name: string;
1831
- stack?: string | undefined;
1832
- stderr?: string | undefined;
1833
- }>;
1834
- declare const GetDeploymentResponseBody: z.ZodObject<{
1835
- id: z.ZodString;
1836
- status: z.ZodEnum<["PENDING", "BUILDING", "DEPLOYING", "DEPLOYED", "FAILED", "CANCELED", "TIMED_OUT"]>;
1837
- contentHash: z.ZodString;
1838
- shortCode: z.ZodString;
1839
- version: z.ZodString;
1840
- imageReference: z.ZodOptional<z.ZodString>;
1841
- errorData: z.ZodNullable<z.ZodOptional<z.ZodObject<{
1842
- name: z.ZodString;
1843
- message: z.ZodString;
1844
- stack: z.ZodOptional<z.ZodString>;
1845
- stderr: z.ZodOptional<z.ZodString>;
1846
- }, "strip", z.ZodTypeAny, {
1847
- message: string;
1848
- name: string;
1849
- stack?: string | undefined;
1850
- stderr?: string | undefined;
1851
- }, {
1852
- message: string;
1853
- name: string;
1854
- stack?: string | undefined;
1855
- stderr?: string | undefined;
1856
- }>>>;
1857
- worker: z.ZodOptional<z.ZodObject<{
1858
- id: z.ZodString;
1859
- version: z.ZodString;
1860
- tasks: z.ZodArray<z.ZodObject<{
1861
- id: z.ZodString;
1862
- slug: z.ZodString;
1863
- filePath: z.ZodString;
1864
- exportName: z.ZodString;
1865
- }, "strip", z.ZodTypeAny, {
1866
- id: string;
1867
- filePath: string;
1868
- exportName: string;
1869
- slug: string;
1870
- }, {
1871
- id: string;
1872
- filePath: string;
1873
- exportName: string;
1874
- slug: string;
1875
- }>, "many">;
1876
- }, "strip", z.ZodTypeAny, {
1877
- id: string;
1878
- version: string;
1879
- tasks: {
1880
- id: string;
1881
- filePath: string;
1882
- exportName: string;
1883
- slug: string;
1884
- }[];
1885
- }, {
1886
- id: string;
1887
- version: string;
1888
- tasks: {
1889
- id: string;
1890
- filePath: string;
1891
- exportName: string;
1892
- slug: string;
1893
- }[];
1894
- }>>;
1895
- }, "strip", z.ZodTypeAny, {
1896
- status: "PENDING" | "CANCELED" | "FAILED" | "BUILDING" | "DEPLOYING" | "DEPLOYED" | "TIMED_OUT";
1897
- id: string;
1898
- version: string;
1899
- contentHash: string;
1900
- shortCode: string;
1901
- imageReference?: string | undefined;
1902
- errorData?: {
1903
- message: string;
1904
- name: string;
1905
- stack?: string | undefined;
1906
- stderr?: string | undefined;
1907
- } | null | undefined;
1908
- worker?: {
1909
- id: string;
1910
- version: string;
1911
- tasks: {
1912
- id: string;
1913
- filePath: string;
1914
- exportName: string;
1915
- slug: string;
1916
- }[];
1917
- } | undefined;
1918
- }, {
1919
- status: "PENDING" | "CANCELED" | "FAILED" | "BUILDING" | "DEPLOYING" | "DEPLOYED" | "TIMED_OUT";
1920
- id: string;
1921
- version: string;
1922
- contentHash: string;
1923
- shortCode: string;
1924
- imageReference?: string | undefined;
1925
- errorData?: {
1926
- message: string;
1927
- name: string;
1928
- stack?: string | undefined;
1929
- stderr?: string | undefined;
1930
- } | null | undefined;
1931
- worker?: {
1932
- id: string;
1933
- version: string;
1934
- tasks: {
1935
- id: string;
1936
- filePath: string;
1937
- exportName: string;
1938
- slug: string;
1939
- }[];
1940
- } | undefined;
1941
- }>;
1942
- type GetDeploymentResponseBody = z.infer<typeof GetDeploymentResponseBody>;
1943
- declare const CreateUploadPayloadUrlResponseBody: z.ZodObject<{
1944
- presignedUrl: z.ZodString;
1945
- }, "strip", z.ZodTypeAny, {
1946
- presignedUrl: string;
1947
- }, {
1948
- presignedUrl: string;
1949
- }>;
1950
- type CreateUploadPayloadUrlResponseBody = z.infer<typeof CreateUploadPayloadUrlResponseBody>;
1951
- declare const ReplayRunResponse: z.ZodObject<{
1952
- id: z.ZodString;
1953
- }, "strip", z.ZodTypeAny, {
1954
- id: string;
1955
- }, {
1956
- id: string;
1957
- }>;
1958
- type ReplayRunResponse = z.infer<typeof ReplayRunResponse>;
1959
- declare const CanceledRunResponse: z.ZodObject<{
1960
- id: z.ZodString;
1961
- }, "strip", z.ZodTypeAny, {
1962
- id: string;
1963
- }, {
1964
- id: string;
1965
- }>;
1966
- type CanceledRunResponse = z.infer<typeof CanceledRunResponse>;
1967
- declare const ScheduledTaskPayload: z.ZodObject<{
1968
- /** The schedule id associated with this run (you can have many schedules for the same task).
1969
- You can use this to remove the schedule, update it, etc */
1970
- scheduleId: z.ZodString;
1971
- /** When the task was scheduled to run.
1972
- * Note this will be slightly different from `new Date()` because it takes a few ms to run the task.
1973
- *
1974
- * This date is UTC. To output it as a string with a timezone you would do this:
1975
- * ```ts
1976
- * const formatted = payload.timestamp.toLocaleString("en-US", {
1977
- timeZone: payload.timezone,
1978
- });
1979
- ``` */
1980
- timestamp: z.ZodDate;
1981
- /** When the task was last run (it has been).
1982
- This can be undefined if it's never been run. This date is UTC. */
1983
- lastTimestamp: z.ZodOptional<z.ZodDate>;
1984
- /** You can optionally provide an external id when creating the schedule.
1985
- Usually you would use a userId or some other unique identifier.
1986
- This defaults to undefined if you didn't provide one. */
1987
- externalId: z.ZodOptional<z.ZodString>;
1988
- /** The IANA timezone the schedule is set to. The default is UTC.
1989
- * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
1990
- */
1991
- timezone: z.ZodString;
1992
- /** The next 5 dates this task is scheduled to run */
1993
- upcoming: z.ZodArray<z.ZodDate, "many">;
1994
- }, "strip", z.ZodTypeAny, {
1995
- timestamp: Date;
1996
- scheduleId: string;
1997
- timezone: string;
1998
- upcoming: Date[];
1999
- lastTimestamp?: Date | undefined;
2000
- externalId?: string | undefined;
2001
- }, {
2002
- timestamp: Date;
2003
- scheduleId: string;
2004
- timezone: string;
2005
- upcoming: Date[];
2006
- lastTimestamp?: Date | undefined;
2007
- externalId?: string | undefined;
2008
- }>;
2009
- type ScheduledTaskPayload = z.infer<typeof ScheduledTaskPayload>;
2010
- declare const CreateScheduleOptions: z.ZodObject<{
2011
- /** The id of the task you want to attach to. */
2012
- task: z.ZodString;
2013
- /** The schedule in CRON format.
2014
- *
2015
- * ```txt
2016
- * * * * * *
2017
- ┬ ┬ ┬ ┬ ┬
2018
- │ │ │ │ |
2019
- │ │ │ │ └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
2020
- │ │ │ └───── month (1 - 12)
2021
- │ │ └────────── day of month (1 - 31, L)
2022
- │ └─────────────── hour (0 - 23)
2023
- └──────────────────── minute (0 - 59)
2024
- * ```
2025
-
2026
- "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
2027
-
2028
- */
2029
- cron: z.ZodString;
2030
- /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
2031
- *
2032
- * This is required to prevent you from creating duplicate schedules. */
2033
- deduplicationKey: z.ZodString;
2034
- /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
2035
- *
2036
- * This allows you to have per-user CRON tasks.
2037
- */
2038
- externalId: z.ZodOptional<z.ZodString>;
2039
- /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
2040
- * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
2041
- *
2042
- * If you set the CRON to `0 0 * * *` and the timezone to `America/New_York` then the task will run at midnight in New York time, no matter whether it's daylight savings or not.
2043
- *
2044
- * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
2045
- *
2046
- * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
2047
- *
2048
- */
2049
- timezone: z.ZodOptional<z.ZodString>;
2050
- }, "strip", z.ZodTypeAny, {
2051
- task: string;
2052
- cron: string;
2053
- deduplicationKey: string;
2054
- externalId?: string | undefined;
2055
- timezone?: string | undefined;
2056
- }, {
2057
- task: string;
2058
- cron: string;
2059
- deduplicationKey: string;
2060
- externalId?: string | undefined;
2061
- timezone?: string | undefined;
2062
- }>;
2063
- type CreateScheduleOptions = z.infer<typeof CreateScheduleOptions>;
2064
- declare const UpdateScheduleOptions: z.ZodObject<Omit<{
2065
- /** The id of the task you want to attach to. */
2066
- task: z.ZodString;
2067
- /** The schedule in CRON format.
2068
- *
2069
- * ```txt
2070
- * * * * * *
2071
- ┬ ┬ ┬ ┬ ┬
2072
- │ │ │ │ |
2073
- │ │ │ │ └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
2074
- │ │ │ └───── month (1 - 12)
2075
- │ │ └────────── day of month (1 - 31, L)
2076
- │ └─────────────── hour (0 - 23)
2077
- └──────────────────── minute (0 - 59)
2078
- * ```
2079
-
2080
- "L" means the last. In the "day of week" field, 1L means the last Monday of the month. In the day of month field, L means the last day of the month.
2081
-
2082
- */
2083
- cron: z.ZodString;
2084
- /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
2085
- *
2086
- * This is required to prevent you from creating duplicate schedules. */
2087
- deduplicationKey: z.ZodString;
2088
- /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
2089
- *
2090
- * This allows you to have per-user CRON tasks.
2091
- */
2092
- externalId: z.ZodOptional<z.ZodString>;
2093
- /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
2094
- * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
2095
- *
2096
- * If you set the CRON to `0 0 * * *` and the timezone to `America/New_York` then the task will run at midnight in New York time, no matter whether it's daylight savings or not.
2097
- *
2098
- * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
2099
- *
2100
- * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
2101
- *
2102
- */
2103
- timezone: z.ZodOptional<z.ZodString>;
2104
- }, "deduplicationKey">, "strip", z.ZodTypeAny, {
2105
- task: string;
2106
- cron: string;
2107
- externalId?: string | undefined;
2108
- timezone?: string | undefined;
2109
- }, {
2110
- task: string;
2111
- cron: string;
2112
- externalId?: string | undefined;
2113
- timezone?: string | undefined;
2114
- }>;
2115
- type UpdateScheduleOptions = z.infer<typeof UpdateScheduleOptions>;
2116
- declare const ScheduleGenerator: z.ZodObject<{
2117
- type: z.ZodLiteral<"CRON">;
2118
- expression: z.ZodString;
2119
- description: z.ZodString;
2120
- }, "strip", z.ZodTypeAny, {
2121
- type: "CRON";
2122
- expression: string;
2123
- description: string;
2124
- }, {
2125
- type: "CRON";
2126
- expression: string;
2127
- description: string;
2128
- }>;
2129
- type ScheduleGenerator = z.infer<typeof ScheduleGenerator>;
2130
- declare const ScheduleObject: z.ZodObject<{
2131
- id: z.ZodString;
2132
- task: z.ZodString;
2133
- active: z.ZodBoolean;
2134
- deduplicationKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
2135
- externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
2136
- generator: z.ZodObject<{
2137
- type: z.ZodLiteral<"CRON">;
2138
- expression: z.ZodString;
2139
- description: z.ZodString;
2140
- }, "strip", z.ZodTypeAny, {
2141
- type: "CRON";
2142
- expression: string;
2143
- description: string;
2144
- }, {
2145
- type: "CRON";
2146
- expression: string;
2147
- description: string;
2148
- }>;
2149
- timezone: z.ZodString;
2150
- nextRun: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
2151
- environments: z.ZodArray<z.ZodObject<{
2152
- id: z.ZodString;
2153
- type: z.ZodString;
2154
- userName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
2155
- }, "strip", z.ZodTypeAny, {
2156
- type: string;
2157
- id: string;
2158
- userName?: string | null | undefined;
2159
- }, {
2160
- type: string;
2161
- id: string;
2162
- userName?: string | null | undefined;
2163
- }>, "many">;
2164
- }, "strip", z.ZodTypeAny, {
2165
- id: string;
2166
- task: string;
2167
- timezone: string;
2168
- active: boolean;
2169
- generator: {
2170
- type: "CRON";
2171
- expression: string;
2172
- description: string;
2173
- };
2174
- environments: {
2175
- type: string;
2176
- id: string;
2177
- userName?: string | null | undefined;
2178
- }[];
2179
- deduplicationKey?: string | null | undefined;
2180
- externalId?: string | null | undefined;
2181
- nextRun?: Date | null | undefined;
2182
- }, {
2183
- id: string;
2184
- task: string;
2185
- timezone: string;
2186
- active: boolean;
2187
- generator: {
2188
- type: "CRON";
2189
- expression: string;
2190
- description: string;
2191
- };
2192
- environments: {
2193
- type: string;
2194
- id: string;
2195
- userName?: string | null | undefined;
2196
- }[];
2197
- deduplicationKey?: string | null | undefined;
2198
- externalId?: string | null | undefined;
2199
- nextRun?: Date | null | undefined;
2200
- }>;
2201
- type ScheduleObject = z.infer<typeof ScheduleObject>;
2202
- declare const DeletedScheduleObject: z.ZodObject<{
2203
- id: z.ZodString;
2204
- }, "strip", z.ZodTypeAny, {
2205
- id: string;
2206
- }, {
2207
- id: string;
2208
- }>;
2209
- type DeletedScheduleObject = z.infer<typeof DeletedScheduleObject>;
2210
- declare const ListSchedulesResult: z.ZodObject<{
2211
- data: z.ZodArray<z.ZodObject<{
2212
- id: z.ZodString;
2213
- task: z.ZodString;
2214
- active: z.ZodBoolean;
2215
- deduplicationKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
2216
- externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
2217
- generator: z.ZodObject<{
2218
- type: z.ZodLiteral<"CRON">;
2219
- expression: z.ZodString;
2220
- description: z.ZodString;
2221
- }, "strip", z.ZodTypeAny, {
2222
- type: "CRON";
2223
- expression: string;
2224
- description: string;
2225
- }, {
2226
- type: "CRON";
2227
- expression: string;
2228
- description: string;
2229
- }>;
2230
- timezone: z.ZodString;
2231
- nextRun: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
2232
- environments: z.ZodArray<z.ZodObject<{
2233
- id: z.ZodString;
2234
- type: z.ZodString;
2235
- userName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
2236
- }, "strip", z.ZodTypeAny, {
2237
- type: string;
2238
- id: string;
2239
- userName?: string | null | undefined;
2240
- }, {
2241
- type: string;
2242
- id: string;
2243
- userName?: string | null | undefined;
2244
- }>, "many">;
2245
- }, "strip", z.ZodTypeAny, {
2246
- id: string;
2247
- task: string;
2248
- timezone: string;
2249
- active: boolean;
2250
- generator: {
2251
- type: "CRON";
2252
- expression: string;
2253
- description: string;
2254
- };
2255
- environments: {
2256
- type: string;
2257
- id: string;
2258
- userName?: string | null | undefined;
2259
- }[];
2260
- deduplicationKey?: string | null | undefined;
2261
- externalId?: string | null | undefined;
2262
- nextRun?: Date | null | undefined;
2263
- }, {
2264
- id: string;
2265
- task: string;
2266
- timezone: string;
2267
- active: boolean;
2268
- generator: {
2269
- type: "CRON";
2270
- expression: string;
2271
- description: string;
2272
- };
2273
- environments: {
2274
- type: string;
2275
- id: string;
2276
- userName?: string | null | undefined;
2277
- }[];
2278
- deduplicationKey?: string | null | undefined;
2279
- externalId?: string | null | undefined;
2280
- nextRun?: Date | null | undefined;
2281
- }>, "many">;
2282
- pagination: z.ZodObject<{
2283
- currentPage: z.ZodNumber;
2284
- totalPages: z.ZodNumber;
2285
- count: z.ZodNumber;
2286
- }, "strip", z.ZodTypeAny, {
2287
- currentPage: number;
2288
- totalPages: number;
2289
- count: number;
2290
- }, {
2291
- currentPage: number;
2292
- totalPages: number;
2293
- count: number;
2294
- }>;
2295
- }, "strip", z.ZodTypeAny, {
2296
- data: {
2297
- id: string;
2298
- task: string;
2299
- timezone: string;
2300
- active: boolean;
2301
- generator: {
2302
- type: "CRON";
2303
- expression: string;
2304
- description: string;
2305
- };
2306
- environments: {
2307
- type: string;
2308
- id: string;
2309
- userName?: string | null | undefined;
2310
- }[];
2311
- deduplicationKey?: string | null | undefined;
2312
- externalId?: string | null | undefined;
2313
- nextRun?: Date | null | undefined;
2314
- }[];
2315
- pagination: {
2316
- currentPage: number;
2317
- totalPages: number;
2318
- count: number;
2319
- };
2320
- }, {
2321
- data: {
2322
- id: string;
2323
- task: string;
2324
- timezone: string;
2325
- active: boolean;
2326
- generator: {
2327
- type: "CRON";
2328
- expression: string;
2329
- description: string;
2330
- };
2331
- environments: {
2332
- type: string;
2333
- id: string;
2334
- userName?: string | null | undefined;
2335
- }[];
2336
- deduplicationKey?: string | null | undefined;
2337
- externalId?: string | null | undefined;
2338
- nextRun?: Date | null | undefined;
2339
- }[];
2340
- pagination: {
2341
- currentPage: number;
2342
- totalPages: number;
2343
- count: number;
2344
- };
2345
- }>;
2346
- type ListSchedulesResult = z.infer<typeof ListSchedulesResult>;
2347
- declare const ListScheduleOptions: z.ZodObject<{
2348
- page: z.ZodOptional<z.ZodNumber>;
2349
- perPage: z.ZodOptional<z.ZodNumber>;
2350
- }, "strip", z.ZodTypeAny, {
2351
- page?: number | undefined;
2352
- perPage?: number | undefined;
2353
- }, {
2354
- page?: number | undefined;
2355
- perPage?: number | undefined;
2356
- }>;
2357
- type ListScheduleOptions = z.infer<typeof ListScheduleOptions>;
2358
- declare const TimezonesResult: z.ZodObject<{
2359
- timezones: z.ZodArray<z.ZodString, "many">;
2360
- }, "strip", z.ZodTypeAny, {
2361
- timezones: string[];
2362
- }, {
2363
- timezones: string[];
2364
- }>;
2365
- type TimezonesResult = z.infer<typeof TimezonesResult>;
2366
- declare const RunStatus: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE"]>;
2367
- type RunStatus = z.infer<typeof RunStatus>;
2368
- declare const AttemptStatus: z.ZodEnum<["PENDING", "EXECUTING", "PAUSED", "COMPLETED", "FAILED", "CANCELED"]>;
2369
- type AttemptStatus = z.infer<typeof AttemptStatus>;
2370
- declare const RunEnvironmentDetails: z.ZodObject<{
2371
- id: z.ZodString;
2372
- name: z.ZodString;
2373
- user: z.ZodOptional<z.ZodString>;
2374
- }, "strip", z.ZodTypeAny, {
2375
- id: string;
2376
- name: string;
2377
- user?: string | undefined;
2378
- }, {
2379
- id: string;
2380
- name: string;
2381
- user?: string | undefined;
2382
- }>;
2383
- type RunEnvironmentDetails = z.infer<typeof RunEnvironmentDetails>;
2384
- declare const RunScheduleDetails: z.ZodObject<{
2385
- id: z.ZodString;
2386
- externalId: z.ZodOptional<z.ZodString>;
2387
- deduplicationKey: z.ZodOptional<z.ZodString>;
2388
- generator: z.ZodObject<{
2389
- type: z.ZodLiteral<"CRON">;
2390
- expression: z.ZodString;
2391
- description: z.ZodString;
2392
- }, "strip", z.ZodTypeAny, {
2393
- type: "CRON";
2394
- expression: string;
2395
- description: string;
2396
- }, {
2397
- type: "CRON";
2398
- expression: string;
2399
- description: string;
2400
- }>;
2401
- }, "strip", z.ZodTypeAny, {
2402
- id: string;
2403
- generator: {
2404
- type: "CRON";
2405
- expression: string;
2406
- description: string;
2407
- };
2408
- externalId?: string | undefined;
2409
- deduplicationKey?: string | undefined;
2410
- }, {
2411
- id: string;
2412
- generator: {
2413
- type: "CRON";
2414
- expression: string;
2415
- description: string;
2416
- };
2417
- externalId?: string | undefined;
2418
- deduplicationKey?: string | undefined;
2419
- }>;
2420
- type RunScheduleDetails = z.infer<typeof RunScheduleDetails>;
2421
- declare const RetrieveRunResponse: z.ZodObject<{
2422
- payload: z.ZodOptional<z.ZodAny>;
2423
- payloadPresignedUrl: z.ZodOptional<z.ZodString>;
2424
- output: z.ZodOptional<z.ZodAny>;
2425
- outputPresignedUrl: z.ZodOptional<z.ZodString>;
2426
- schedule: z.ZodOptional<z.ZodObject<{
2427
- id: z.ZodString;
2428
- externalId: z.ZodOptional<z.ZodString>;
2429
- deduplicationKey: z.ZodOptional<z.ZodString>;
2430
- generator: z.ZodObject<{
2431
- type: z.ZodLiteral<"CRON">;
2432
- expression: z.ZodString;
2433
- description: z.ZodString;
2434
- }, "strip", z.ZodTypeAny, {
2435
- type: "CRON";
2436
- expression: string;
2437
- description: string;
2438
- }, {
2439
- type: "CRON";
2440
- expression: string;
2441
- description: string;
2442
- }>;
2443
- }, "strip", z.ZodTypeAny, {
2444
- id: string;
2445
- generator: {
2446
- type: "CRON";
2447
- expression: string;
2448
- description: string;
2449
- };
2450
- externalId?: string | undefined;
2451
- deduplicationKey?: string | undefined;
2452
- }, {
2453
- id: string;
2454
- generator: {
2455
- type: "CRON";
2456
- expression: string;
2457
- description: string;
2458
- };
2459
- externalId?: string | undefined;
2460
- deduplicationKey?: string | undefined;
2461
- }>>;
2462
- attempts: z.ZodArray<z.ZodOptional<z.ZodObject<{
2463
- id: z.ZodString;
2464
- status: z.ZodEnum<["PENDING", "EXECUTING", "PAUSED", "COMPLETED", "FAILED", "CANCELED"]>;
2465
- createdAt: z.ZodDate;
2466
- updatedAt: z.ZodDate;
2467
- startedAt: z.ZodOptional<z.ZodDate>;
2468
- completedAt: z.ZodOptional<z.ZodDate>;
2469
- error: z.ZodOptional<z.ZodObject<{
2470
- message: z.ZodString;
2471
- name: z.ZodOptional<z.ZodString>;
2472
- stackTrace: z.ZodOptional<z.ZodString>;
2473
- }, "strip", z.ZodTypeAny, {
2474
- message: string;
2475
- name?: string | undefined;
2476
- stackTrace?: string | undefined;
2477
- }, {
2478
- message: string;
2479
- name?: string | undefined;
2480
- stackTrace?: string | undefined;
2481
- }>>;
2482
- }, "strip", z.ZodTypeAny, {
2483
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
2484
- id: string;
2485
- createdAt: Date;
2486
- updatedAt: Date;
2487
- startedAt?: Date | undefined;
2488
- completedAt?: Date | undefined;
2489
- error?: {
2490
- message: string;
2491
- name?: string | undefined;
2492
- stackTrace?: string | undefined;
2493
- } | undefined;
2494
- }, {
2495
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
2496
- id: string;
2497
- createdAt: Date;
2498
- updatedAt: Date;
2499
- startedAt?: Date | undefined;
2500
- completedAt?: Date | undefined;
2501
- error?: {
2502
- message: string;
2503
- name?: string | undefined;
2504
- stackTrace?: string | undefined;
2505
- } | undefined;
2506
- }>>, "many">;
2507
- id: z.ZodString;
2508
- status: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE"]>;
2509
- taskIdentifier: z.ZodString;
2510
- idempotencyKey: z.ZodOptional<z.ZodString>;
2511
- version: z.ZodOptional<z.ZodString>;
2512
- isQueued: z.ZodBoolean;
2513
- isExecuting: z.ZodBoolean;
2514
- isCompleted: z.ZodBoolean;
2515
- isSuccess: z.ZodBoolean;
2516
- isFailed: z.ZodBoolean;
2517
- isCancelled: z.ZodBoolean;
2518
- isTest: z.ZodBoolean;
2519
- createdAt: z.ZodDate;
2520
- updatedAt: z.ZodDate;
2521
- startedAt: z.ZodOptional<z.ZodDate>;
2522
- finishedAt: z.ZodOptional<z.ZodDate>;
2523
- }, "strip", z.ZodTypeAny, {
2524
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2525
- id: string;
2526
- isTest: boolean;
2527
- createdAt: Date;
2528
- attempts: ({
2529
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
2530
- id: string;
2531
- createdAt: Date;
2532
- updatedAt: Date;
2533
- startedAt?: Date | undefined;
2534
- completedAt?: Date | undefined;
2535
- error?: {
2536
- message: string;
2537
- name?: string | undefined;
2538
- stackTrace?: string | undefined;
2539
- } | undefined;
2540
- } | undefined)[];
2541
- updatedAt: Date;
2542
- taskIdentifier: string;
2543
- isQueued: boolean;
2544
- isExecuting: boolean;
2545
- isCompleted: boolean;
2546
- isSuccess: boolean;
2547
- isFailed: boolean;
2548
- isCancelled: boolean;
2549
- payload?: any;
2550
- payloadPresignedUrl?: string | undefined;
2551
- output?: any;
2552
- outputPresignedUrl?: string | undefined;
2553
- schedule?: {
2554
- id: string;
2555
- generator: {
2556
- type: "CRON";
2557
- expression: string;
2558
- description: string;
2559
- };
2560
- externalId?: string | undefined;
2561
- deduplicationKey?: string | undefined;
2562
- } | undefined;
2563
- idempotencyKey?: string | undefined;
2564
- version?: string | undefined;
2565
- startedAt?: Date | undefined;
2566
- finishedAt?: Date | undefined;
2567
- }, {
2568
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2569
- id: string;
2570
- isTest: boolean;
2571
- createdAt: Date;
2572
- attempts: ({
2573
- status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
2574
- id: string;
2575
- createdAt: Date;
2576
- updatedAt: Date;
2577
- startedAt?: Date | undefined;
2578
- completedAt?: Date | undefined;
2579
- error?: {
2580
- message: string;
2581
- name?: string | undefined;
2582
- stackTrace?: string | undefined;
2583
- } | undefined;
2584
- } | undefined)[];
2585
- updatedAt: Date;
2586
- taskIdentifier: string;
2587
- isQueued: boolean;
2588
- isExecuting: boolean;
2589
- isCompleted: boolean;
2590
- isSuccess: boolean;
2591
- isFailed: boolean;
2592
- isCancelled: boolean;
2593
- payload?: any;
2594
- payloadPresignedUrl?: string | undefined;
2595
- output?: any;
2596
- outputPresignedUrl?: string | undefined;
2597
- schedule?: {
2598
- id: string;
2599
- generator: {
2600
- type: "CRON";
2601
- expression: string;
2602
- description: string;
2603
- };
2604
- externalId?: string | undefined;
2605
- deduplicationKey?: string | undefined;
2606
- } | undefined;
2607
- idempotencyKey?: string | undefined;
2608
- version?: string | undefined;
2609
- startedAt?: Date | undefined;
2610
- finishedAt?: Date | undefined;
2611
- }>;
2612
- type RetrieveRunResponse = z.infer<typeof RetrieveRunResponse>;
2613
- declare const ListRunResponseItem: z.ZodObject<{
2614
- env: z.ZodObject<{
2615
- id: z.ZodString;
2616
- name: z.ZodString;
2617
- user: z.ZodOptional<z.ZodString>;
2618
- }, "strip", z.ZodTypeAny, {
2619
- id: string;
2620
- name: string;
2621
- user?: string | undefined;
2622
- }, {
2623
- id: string;
2624
- name: string;
2625
- user?: string | undefined;
2626
- }>;
2627
- id: z.ZodString;
2628
- status: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE"]>;
2629
- taskIdentifier: z.ZodString;
2630
- idempotencyKey: z.ZodOptional<z.ZodString>;
2631
- version: z.ZodOptional<z.ZodString>;
2632
- isQueued: z.ZodBoolean;
2633
- isExecuting: z.ZodBoolean;
2634
- isCompleted: z.ZodBoolean;
2635
- isSuccess: z.ZodBoolean;
2636
- isFailed: z.ZodBoolean;
2637
- isCancelled: z.ZodBoolean;
2638
- isTest: z.ZodBoolean;
2639
- createdAt: z.ZodDate;
2640
- updatedAt: z.ZodDate;
2641
- startedAt: z.ZodOptional<z.ZodDate>;
2642
- finishedAt: z.ZodOptional<z.ZodDate>;
2643
- }, "strip", z.ZodTypeAny, {
2644
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2645
- id: string;
2646
- isTest: boolean;
2647
- createdAt: Date;
2648
- updatedAt: Date;
2649
- taskIdentifier: string;
2650
- isQueued: boolean;
2651
- isExecuting: boolean;
2652
- isCompleted: boolean;
2653
- isSuccess: boolean;
2654
- isFailed: boolean;
2655
- isCancelled: boolean;
2656
- env: {
2657
- id: string;
2658
- name: string;
2659
- user?: string | undefined;
2660
- };
2661
- idempotencyKey?: string | undefined;
2662
- version?: string | undefined;
2663
- startedAt?: Date | undefined;
2664
- finishedAt?: Date | undefined;
2665
- }, {
2666
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2667
- id: string;
2668
- isTest: boolean;
2669
- createdAt: Date;
2670
- updatedAt: Date;
2671
- taskIdentifier: string;
2672
- isQueued: boolean;
2673
- isExecuting: boolean;
2674
- isCompleted: boolean;
2675
- isSuccess: boolean;
2676
- isFailed: boolean;
2677
- isCancelled: boolean;
2678
- env: {
2679
- id: string;
2680
- name: string;
2681
- user?: string | undefined;
2682
- };
2683
- idempotencyKey?: string | undefined;
2684
- version?: string | undefined;
2685
- startedAt?: Date | undefined;
2686
- finishedAt?: Date | undefined;
2687
- }>;
2688
- type ListRunResponseItem = z.infer<typeof ListRunResponseItem>;
2689
- declare const ListRunResponse: z.ZodObject<{
2690
- data: z.ZodArray<z.ZodObject<{
2691
- env: z.ZodObject<{
2692
- id: z.ZodString;
2693
- name: z.ZodString;
2694
- user: z.ZodOptional<z.ZodString>;
2695
- }, "strip", z.ZodTypeAny, {
2696
- id: string;
2697
- name: string;
2698
- user?: string | undefined;
2699
- }, {
2700
- id: string;
2701
- name: string;
2702
- user?: string | undefined;
2703
- }>;
2704
- id: z.ZodString;
2705
- status: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE"]>;
2706
- taskIdentifier: z.ZodString;
2707
- idempotencyKey: z.ZodOptional<z.ZodString>;
2708
- version: z.ZodOptional<z.ZodString>;
2709
- isQueued: z.ZodBoolean;
2710
- isExecuting: z.ZodBoolean;
2711
- isCompleted: z.ZodBoolean;
2712
- isSuccess: z.ZodBoolean;
2713
- isFailed: z.ZodBoolean;
2714
- isCancelled: z.ZodBoolean;
2715
- isTest: z.ZodBoolean;
2716
- createdAt: z.ZodDate;
2717
- updatedAt: z.ZodDate;
2718
- startedAt: z.ZodOptional<z.ZodDate>;
2719
- finishedAt: z.ZodOptional<z.ZodDate>;
2720
- }, "strip", z.ZodTypeAny, {
2721
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2722
- id: string;
2723
- isTest: boolean;
2724
- createdAt: Date;
2725
- updatedAt: Date;
2726
- taskIdentifier: string;
2727
- isQueued: boolean;
2728
- isExecuting: boolean;
2729
- isCompleted: boolean;
2730
- isSuccess: boolean;
2731
- isFailed: boolean;
2732
- isCancelled: boolean;
2733
- env: {
2734
- id: string;
2735
- name: string;
2736
- user?: string | undefined;
2737
- };
2738
- idempotencyKey?: string | undefined;
2739
- version?: string | undefined;
2740
- startedAt?: Date | undefined;
2741
- finishedAt?: Date | undefined;
2742
- }, {
2743
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2744
- id: string;
2745
- isTest: boolean;
2746
- createdAt: Date;
2747
- updatedAt: Date;
2748
- taskIdentifier: string;
2749
- isQueued: boolean;
2750
- isExecuting: boolean;
2751
- isCompleted: boolean;
2752
- isSuccess: boolean;
2753
- isFailed: boolean;
2754
- isCancelled: boolean;
2755
- env: {
2756
- id: string;
2757
- name: string;
2758
- user?: string | undefined;
2759
- };
2760
- idempotencyKey?: string | undefined;
2761
- version?: string | undefined;
2762
- startedAt?: Date | undefined;
2763
- finishedAt?: Date | undefined;
2764
- }>, "many">;
2765
- pagination: z.ZodObject<{
2766
- next: z.ZodOptional<z.ZodString>;
2767
- previous: z.ZodOptional<z.ZodString>;
2768
- }, "strip", z.ZodTypeAny, {
2769
- next?: string | undefined;
2770
- previous?: string | undefined;
2771
- }, {
2772
- next?: string | undefined;
2773
- previous?: string | undefined;
2774
- }>;
2775
- }, "strip", z.ZodTypeAny, {
2776
- data: {
2777
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2778
- id: string;
2779
- isTest: boolean;
2780
- createdAt: Date;
2781
- updatedAt: Date;
2782
- taskIdentifier: string;
2783
- isQueued: boolean;
2784
- isExecuting: boolean;
2785
- isCompleted: boolean;
2786
- isSuccess: boolean;
2787
- isFailed: boolean;
2788
- isCancelled: boolean;
2789
- env: {
2790
- id: string;
2791
- name: string;
2792
- user?: string | undefined;
2793
- };
2794
- idempotencyKey?: string | undefined;
2795
- version?: string | undefined;
2796
- startedAt?: Date | undefined;
2797
- finishedAt?: Date | undefined;
2798
- }[];
2799
- pagination: {
2800
- next?: string | undefined;
2801
- previous?: string | undefined;
2802
- };
2803
- }, {
2804
- data: {
2805
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
2806
- id: string;
2807
- isTest: boolean;
2808
- createdAt: Date;
2809
- updatedAt: Date;
2810
- taskIdentifier: string;
2811
- isQueued: boolean;
2812
- isExecuting: boolean;
2813
- isCompleted: boolean;
2814
- isSuccess: boolean;
2815
- isFailed: boolean;
2816
- isCancelled: boolean;
2817
- env: {
2818
- id: string;
2819
- name: string;
2820
- user?: string | undefined;
2821
- };
2822
- idempotencyKey?: string | undefined;
2823
- version?: string | undefined;
2824
- startedAt?: Date | undefined;
2825
- finishedAt?: Date | undefined;
2826
- }[];
2827
- pagination: {
2828
- next?: string | undefined;
2829
- previous?: string | undefined;
2830
- };
2831
- }>;
2832
- type ListRunResponse = z.infer<typeof ListRunResponse>;
2833
- declare const CreateEnvironmentVariableRequestBody: z.ZodObject<{
2834
- name: z.ZodString;
2835
- value: z.ZodString;
2836
- }, "strip", z.ZodTypeAny, {
2837
- value: string;
2838
- name: string;
2839
- }, {
2840
- value: string;
2841
- name: string;
2842
- }>;
2843
- type CreateEnvironmentVariableRequestBody = z.infer<typeof CreateEnvironmentVariableRequestBody>;
2844
- declare const UpdateEnvironmentVariableRequestBody: z.ZodObject<{
2845
- value: z.ZodString;
2846
- }, "strip", z.ZodTypeAny, {
2847
- value: string;
2848
- }, {
2849
- value: string;
2850
- }>;
2851
- type UpdateEnvironmentVariableRequestBody = z.infer<typeof UpdateEnvironmentVariableRequestBody>;
2852
- declare const ImportEnvironmentVariablesRequestBody: z.ZodObject<{
2853
- variables: z.ZodRecord<z.ZodString, z.ZodString>;
2854
- override: z.ZodOptional<z.ZodBoolean>;
2855
- }, "strip", z.ZodTypeAny, {
2856
- variables: Record<string, string>;
2857
- override?: boolean | undefined;
2858
- }, {
2859
- variables: Record<string, string>;
2860
- override?: boolean | undefined;
2861
- }>;
2862
- type ImportEnvironmentVariablesRequestBody = z.infer<typeof ImportEnvironmentVariablesRequestBody>;
2863
- declare const EnvironmentVariableResponseBody: z.ZodObject<{
2864
- success: z.ZodBoolean;
2865
- }, "strip", z.ZodTypeAny, {
2866
- success: boolean;
2867
- }, {
2868
- success: boolean;
2869
- }>;
2870
- type EnvironmentVariableResponseBody = z.infer<typeof EnvironmentVariableResponseBody>;
2871
- declare const EnvironmentVariableValue: z.ZodObject<{
2872
- value: z.ZodString;
2873
- }, "strip", z.ZodTypeAny, {
2874
- value: string;
2875
- }, {
2876
- value: string;
2877
- }>;
2878
- type EnvironmentVariableValue = z.infer<typeof EnvironmentVariableValue>;
2879
- declare const EnvironmentVariable: z.ZodObject<{
2880
- name: z.ZodString;
2881
- value: z.ZodString;
2882
- }, "strip", z.ZodTypeAny, {
2883
- value: string;
2884
- name: string;
2885
- }, {
2886
- value: string;
2887
- name: string;
2888
- }>;
2889
- declare const EnvironmentVariables: z.ZodArray<z.ZodObject<{
2890
- name: z.ZodString;
2891
- value: z.ZodString;
2892
- }, "strip", z.ZodTypeAny, {
2893
- value: string;
2894
- name: string;
2895
- }, {
2896
- value: string;
2897
- name: string;
2898
- }>, "many">;
2899
- type EnvironmentVariables = z.infer<typeof EnvironmentVariables>;
2900
-
2901
- declare const TaskResource: z.ZodObject<{
2902
- id: z.ZodString;
2903
- filePath: z.ZodString;
2904
- exportName: z.ZodString;
2905
- queue: z.ZodOptional<z.ZodObject<{
2906
- name: z.ZodOptional<z.ZodString>;
2907
- concurrencyLimit: z.ZodOptional<z.ZodNumber>;
2908
- rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
2909
- type: z.ZodLiteral<"fixed-window">;
2910
- limit: z.ZodNumber;
2911
- window: z.ZodUnion<[z.ZodObject<{
2912
- seconds: z.ZodNumber;
2913
- }, "strip", z.ZodTypeAny, {
2914
- seconds: number;
2915
- }, {
2916
- seconds: number;
2917
- }>, z.ZodObject<{
2918
- minutes: z.ZodNumber;
2919
- }, "strip", z.ZodTypeAny, {
2920
- minutes: number;
2921
- }, {
2922
- minutes: number;
2923
- }>, z.ZodObject<{
2924
- hours: z.ZodNumber;
2925
- }, "strip", z.ZodTypeAny, {
2926
- hours: number;
2927
- }, {
2928
- hours: number;
2929
- }>]>;
2930
- }, "strip", z.ZodTypeAny, {
2931
- type: "fixed-window";
2932
- limit: number;
2933
- window: ({
2934
- seconds: number;
2935
- } | {
2936
- minutes: number;
2937
- } | {
2938
- hours: number;
2939
- }) & ({
2940
- seconds: number;
2941
- } | {
2942
- minutes: number;
2943
- } | {
2944
- hours: number;
2945
- } | undefined);
2946
- }, {
2947
- type: "fixed-window";
2948
- limit: number;
2949
- window: ({
2950
- seconds: number;
2951
- } | {
2952
- minutes: number;
2953
- } | {
2954
- hours: number;
2955
- }) & ({
2956
- seconds: number;
2957
- } | {
2958
- minutes: number;
2959
- } | {
2960
- hours: number;
2961
- } | undefined);
2962
- }>, z.ZodObject<{
2963
- type: z.ZodLiteral<"sliding-window">;
2964
- limit: z.ZodNumber;
2965
- window: z.ZodUnion<[z.ZodObject<{
2966
- seconds: z.ZodNumber;
2967
- }, "strip", z.ZodTypeAny, {
2968
- seconds: number;
2969
- }, {
2970
- seconds: number;
2971
- }>, z.ZodObject<{
2972
- minutes: z.ZodNumber;
2973
- }, "strip", z.ZodTypeAny, {
2974
- minutes: number;
2975
- }, {
2976
- minutes: number;
2977
- }>, z.ZodObject<{
2978
- hours: z.ZodNumber;
2979
- }, "strip", z.ZodTypeAny, {
2980
- hours: number;
2981
- }, {
2982
- hours: number;
2983
- }>]>;
2984
- }, "strip", z.ZodTypeAny, {
2985
- type: "sliding-window";
2986
- limit: number;
2987
- window: ({
2988
- seconds: number;
2989
- } | {
2990
- minutes: number;
2991
- } | {
2992
- hours: number;
2993
- }) & ({
2994
- seconds: number;
2995
- } | {
2996
- minutes: number;
2997
- } | {
2998
- hours: number;
2999
- } | undefined);
3000
- }, {
3001
- type: "sliding-window";
3002
- limit: number;
3003
- window: ({
3004
- seconds: number;
3005
- } | {
3006
- minutes: number;
3007
- } | {
3008
- hours: number;
3009
- }) & ({
3010
- seconds: number;
3011
- } | {
3012
- minutes: number;
3013
- } | {
3014
- hours: number;
3015
- } | undefined);
3016
- }>]>>;
3017
- }, "strip", z.ZodTypeAny, {
3018
- name?: string | undefined;
3019
- concurrencyLimit?: number | undefined;
3020
- rateLimit?: {
3021
- type: "fixed-window";
3022
- limit: number;
3023
- window: ({
3024
- seconds: number;
3025
- } | {
3026
- minutes: number;
3027
- } | {
3028
- hours: number;
3029
- }) & ({
3030
- seconds: number;
3031
- } | {
3032
- minutes: number;
3033
- } | {
3034
- hours: number;
3035
- } | undefined);
3036
- } | {
3037
- type: "sliding-window";
3038
- limit: number;
3039
- window: ({
3040
- seconds: number;
3041
- } | {
3042
- minutes: number;
3043
- } | {
3044
- hours: number;
3045
- }) & ({
3046
- seconds: number;
3047
- } | {
3048
- minutes: number;
3049
- } | {
3050
- hours: number;
3051
- } | undefined);
3052
- } | undefined;
3053
- }, {
3054
- name?: string | undefined;
3055
- concurrencyLimit?: number | undefined;
3056
- rateLimit?: {
3057
- type: "fixed-window";
3058
- limit: number;
3059
- window: ({
3060
- seconds: number;
3061
- } | {
3062
- minutes: number;
3063
- } | {
3064
- hours: number;
3065
- }) & ({
3066
- seconds: number;
3067
- } | {
3068
- minutes: number;
3069
- } | {
3070
- hours: number;
3071
- } | undefined);
3072
- } | {
3073
- type: "sliding-window";
3074
- limit: number;
3075
- window: ({
3076
- seconds: number;
3077
- } | {
3078
- minutes: number;
3079
- } | {
3080
- hours: number;
3081
- }) & ({
3082
- seconds: number;
3083
- } | {
3084
- minutes: number;
3085
- } | {
3086
- hours: number;
3087
- } | undefined);
3088
- } | undefined;
3089
- }>>;
3090
- retry: z.ZodOptional<z.ZodObject<{
3091
- maxAttempts: z.ZodOptional<z.ZodNumber>;
3092
- factor: z.ZodOptional<z.ZodNumber>;
3093
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3094
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3095
- randomize: z.ZodOptional<z.ZodBoolean>;
3096
- }, "strip", z.ZodTypeAny, {
3097
- maxAttempts?: number | undefined;
3098
- factor?: number | undefined;
3099
- minTimeoutInMs?: number | undefined;
3100
- maxTimeoutInMs?: number | undefined;
3101
- randomize?: boolean | undefined;
3102
- }, {
3103
- maxAttempts?: number | undefined;
3104
- factor?: number | undefined;
3105
- minTimeoutInMs?: number | undefined;
3106
- maxTimeoutInMs?: number | undefined;
3107
- randomize?: boolean | undefined;
3108
- }>>;
3109
- machine: z.ZodOptional<z.ZodObject<{
3110
- cpu: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
3111
- memory: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
3112
- preset: z.ZodOptional<z.ZodEnum<["micro", "small-1x", "small-2x", "medium-1x", "medium-2x", "large-1x", "large-2x"]>>;
3113
- }, "strip", z.ZodTypeAny, {
3114
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3115
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3116
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3117
- }, {
3118
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3119
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3120
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3121
- }>>;
3122
- triggerSource: z.ZodOptional<z.ZodString>;
3123
- }, "strip", z.ZodTypeAny, {
3124
- id: string;
3125
- filePath: string;
3126
- exportName: string;
3127
- queue?: {
3128
- name?: string | undefined;
3129
- concurrencyLimit?: number | undefined;
3130
- rateLimit?: {
3131
- type: "fixed-window";
3132
- limit: number;
3133
- window: ({
3134
- seconds: number;
3135
- } | {
3136
- minutes: number;
3137
- } | {
3138
- hours: number;
3139
- }) & ({
3140
- seconds: number;
3141
- } | {
3142
- minutes: number;
3143
- } | {
3144
- hours: number;
3145
- } | undefined);
3146
- } | {
3147
- type: "sliding-window";
3148
- limit: number;
3149
- window: ({
3150
- seconds: number;
3151
- } | {
3152
- minutes: number;
3153
- } | {
3154
- hours: number;
3155
- }) & ({
3156
- seconds: number;
3157
- } | {
3158
- minutes: number;
3159
- } | {
3160
- hours: number;
3161
- } | undefined);
3162
- } | undefined;
3163
- } | undefined;
3164
- retry?: {
3165
- maxAttempts?: number | undefined;
3166
- factor?: number | undefined;
3167
- minTimeoutInMs?: number | undefined;
3168
- maxTimeoutInMs?: number | undefined;
3169
- randomize?: boolean | undefined;
3170
- } | undefined;
3171
- machine?: {
3172
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3173
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3174
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3175
- } | undefined;
3176
- triggerSource?: string | undefined;
3177
- }, {
3178
- id: string;
3179
- filePath: string;
3180
- exportName: string;
3181
- queue?: {
3182
- name?: string | undefined;
3183
- concurrencyLimit?: number | undefined;
3184
- rateLimit?: {
3185
- type: "fixed-window";
3186
- limit: number;
3187
- window: ({
3188
- seconds: number;
3189
- } | {
3190
- minutes: number;
3191
- } | {
3192
- hours: number;
3193
- }) & ({
3194
- seconds: number;
3195
- } | {
3196
- minutes: number;
3197
- } | {
3198
- hours: number;
3199
- } | undefined);
3200
- } | {
3201
- type: "sliding-window";
3202
- limit: number;
3203
- window: ({
3204
- seconds: number;
3205
- } | {
3206
- minutes: number;
3207
- } | {
3208
- hours: number;
3209
- }) & ({
3210
- seconds: number;
3211
- } | {
3212
- minutes: number;
3213
- } | {
3214
- hours: number;
3215
- } | undefined);
3216
- } | undefined;
3217
- } | undefined;
3218
- retry?: {
3219
- maxAttempts?: number | undefined;
3220
- factor?: number | undefined;
3221
- minTimeoutInMs?: number | undefined;
3222
- maxTimeoutInMs?: number | undefined;
3223
- randomize?: boolean | undefined;
3224
- } | undefined;
3225
- machine?: {
3226
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3227
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3228
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3229
- } | undefined;
3230
- triggerSource?: string | undefined;
3231
- }>;
3232
- type TaskResource = z.infer<typeof TaskResource>;
3233
- declare const BackgroundWorkerMetadata: z.ZodObject<{
3234
- packageVersion: z.ZodString;
3235
- contentHash: z.ZodString;
3236
- cliPackageVersion: z.ZodOptional<z.ZodString>;
3237
- tasks: z.ZodArray<z.ZodObject<{
3238
- id: z.ZodString;
3239
- filePath: z.ZodString;
3240
- exportName: z.ZodString;
3241
- queue: z.ZodOptional<z.ZodObject<{
3242
- name: z.ZodOptional<z.ZodString>;
3243
- concurrencyLimit: z.ZodOptional<z.ZodNumber>;
3244
- rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
3245
- type: z.ZodLiteral<"fixed-window">;
3246
- limit: z.ZodNumber;
3247
- window: z.ZodUnion<[z.ZodObject<{
3248
- seconds: z.ZodNumber;
3249
- }, "strip", z.ZodTypeAny, {
3250
- seconds: number;
3251
- }, {
3252
- seconds: number;
3253
- }>, z.ZodObject<{
3254
- minutes: z.ZodNumber;
3255
- }, "strip", z.ZodTypeAny, {
3256
- minutes: number;
3257
- }, {
3258
- minutes: number;
3259
- }>, z.ZodObject<{
3260
- hours: z.ZodNumber;
3261
- }, "strip", z.ZodTypeAny, {
3262
- hours: number;
3263
- }, {
3264
- hours: number;
3265
- }>]>;
3266
- }, "strip", z.ZodTypeAny, {
3267
- type: "fixed-window";
3268
- limit: number;
3269
- window: ({
3270
- seconds: number;
3271
- } | {
3272
- minutes: number;
3273
- } | {
3274
- hours: number;
3275
- }) & ({
3276
- seconds: number;
3277
- } | {
3278
- minutes: number;
3279
- } | {
3280
- hours: number;
3281
- } | undefined);
3282
- }, {
3283
- type: "fixed-window";
3284
- limit: number;
3285
- window: ({
3286
- seconds: number;
3287
- } | {
3288
- minutes: number;
3289
- } | {
3290
- hours: number;
3291
- }) & ({
3292
- seconds: number;
3293
- } | {
3294
- minutes: number;
3295
- } | {
3296
- hours: number;
3297
- } | undefined);
3298
- }>, z.ZodObject<{
3299
- type: z.ZodLiteral<"sliding-window">;
3300
- limit: z.ZodNumber;
3301
- window: z.ZodUnion<[z.ZodObject<{
3302
- seconds: z.ZodNumber;
3303
- }, "strip", z.ZodTypeAny, {
3304
- seconds: number;
3305
- }, {
3306
- seconds: number;
3307
- }>, z.ZodObject<{
3308
- minutes: z.ZodNumber;
3309
- }, "strip", z.ZodTypeAny, {
3310
- minutes: number;
3311
- }, {
3312
- minutes: number;
3313
- }>, z.ZodObject<{
3314
- hours: z.ZodNumber;
3315
- }, "strip", z.ZodTypeAny, {
3316
- hours: number;
3317
- }, {
3318
- hours: number;
3319
- }>]>;
3320
- }, "strip", z.ZodTypeAny, {
3321
- type: "sliding-window";
3322
- limit: number;
3323
- window: ({
3324
- seconds: number;
3325
- } | {
3326
- minutes: number;
3327
- } | {
3328
- hours: number;
3329
- }) & ({
3330
- seconds: number;
3331
- } | {
3332
- minutes: number;
3333
- } | {
3334
- hours: number;
3335
- } | undefined);
3336
- }, {
3337
- type: "sliding-window";
3338
- limit: number;
3339
- window: ({
3340
- seconds: number;
3341
- } | {
3342
- minutes: number;
3343
- } | {
3344
- hours: number;
3345
- }) & ({
3346
- seconds: number;
3347
- } | {
3348
- minutes: number;
3349
- } | {
3350
- hours: number;
3351
- } | undefined);
3352
- }>]>>;
3353
- }, "strip", z.ZodTypeAny, {
3354
- name?: string | undefined;
3355
- concurrencyLimit?: number | undefined;
3356
- rateLimit?: {
3357
- type: "fixed-window";
3358
- limit: number;
3359
- window: ({
3360
- seconds: number;
3361
- } | {
3362
- minutes: number;
3363
- } | {
3364
- hours: number;
3365
- }) & ({
3366
- seconds: number;
3367
- } | {
3368
- minutes: number;
3369
- } | {
3370
- hours: number;
3371
- } | undefined);
3372
- } | {
3373
- type: "sliding-window";
3374
- limit: number;
3375
- window: ({
3376
- seconds: number;
3377
- } | {
3378
- minutes: number;
3379
- } | {
3380
- hours: number;
3381
- }) & ({
3382
- seconds: number;
3383
- } | {
3384
- minutes: number;
3385
- } | {
3386
- hours: number;
3387
- } | undefined);
3388
- } | undefined;
3389
- }, {
3390
- name?: string | undefined;
3391
- concurrencyLimit?: number | undefined;
3392
- rateLimit?: {
3393
- type: "fixed-window";
3394
- limit: number;
3395
- window: ({
3396
- seconds: number;
3397
- } | {
3398
- minutes: number;
3399
- } | {
3400
- hours: number;
3401
- }) & ({
3402
- seconds: number;
3403
- } | {
3404
- minutes: number;
3405
- } | {
3406
- hours: number;
3407
- } | undefined);
3408
- } | {
3409
- type: "sliding-window";
3410
- limit: number;
3411
- window: ({
3412
- seconds: number;
3413
- } | {
3414
- minutes: number;
3415
- } | {
3416
- hours: number;
3417
- }) & ({
3418
- seconds: number;
3419
- } | {
3420
- minutes: number;
3421
- } | {
3422
- hours: number;
3423
- } | undefined);
3424
- } | undefined;
3425
- }>>;
3426
- retry: z.ZodOptional<z.ZodObject<{
3427
- maxAttempts: z.ZodOptional<z.ZodNumber>;
3428
- factor: z.ZodOptional<z.ZodNumber>;
3429
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3430
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3431
- randomize: z.ZodOptional<z.ZodBoolean>;
3432
- }, "strip", z.ZodTypeAny, {
3433
- maxAttempts?: number | undefined;
3434
- factor?: number | undefined;
3435
- minTimeoutInMs?: number | undefined;
3436
- maxTimeoutInMs?: number | undefined;
3437
- randomize?: boolean | undefined;
3438
- }, {
3439
- maxAttempts?: number | undefined;
3440
- factor?: number | undefined;
3441
- minTimeoutInMs?: number | undefined;
3442
- maxTimeoutInMs?: number | undefined;
3443
- randomize?: boolean | undefined;
3444
- }>>;
3445
- machine: z.ZodOptional<z.ZodObject<{
3446
- cpu: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
3447
- memory: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
3448
- preset: z.ZodOptional<z.ZodEnum<["micro", "small-1x", "small-2x", "medium-1x", "medium-2x", "large-1x", "large-2x"]>>;
3449
- }, "strip", z.ZodTypeAny, {
3450
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3451
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3452
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3453
- }, {
3454
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3455
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3456
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3457
- }>>;
3458
- triggerSource: z.ZodOptional<z.ZodString>;
3459
- }, "strip", z.ZodTypeAny, {
3460
- id: string;
3461
- filePath: string;
3462
- exportName: string;
3463
- queue?: {
3464
- name?: string | undefined;
3465
- concurrencyLimit?: number | undefined;
3466
- rateLimit?: {
3467
- type: "fixed-window";
3468
- limit: number;
3469
- window: ({
3470
- seconds: number;
3471
- } | {
3472
- minutes: number;
3473
- } | {
3474
- hours: number;
3475
- }) & ({
3476
- seconds: number;
3477
- } | {
3478
- minutes: number;
3479
- } | {
3480
- hours: number;
3481
- } | undefined);
3482
- } | {
3483
- type: "sliding-window";
3484
- limit: number;
3485
- window: ({
3486
- seconds: number;
3487
- } | {
3488
- minutes: number;
3489
- } | {
3490
- hours: number;
3491
- }) & ({
3492
- seconds: number;
3493
- } | {
3494
- minutes: number;
3495
- } | {
3496
- hours: number;
3497
- } | undefined);
3498
- } | undefined;
3499
- } | undefined;
3500
- retry?: {
3501
- maxAttempts?: number | undefined;
3502
- factor?: number | undefined;
3503
- minTimeoutInMs?: number | undefined;
3504
- maxTimeoutInMs?: number | undefined;
3505
- randomize?: boolean | undefined;
3506
- } | undefined;
3507
- machine?: {
3508
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3509
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3510
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3511
- } | undefined;
3512
- triggerSource?: string | undefined;
3513
- }, {
3514
- id: string;
3515
- filePath: string;
3516
- exportName: string;
3517
- queue?: {
3518
- name?: string | undefined;
3519
- concurrencyLimit?: number | undefined;
3520
- rateLimit?: {
3521
- type: "fixed-window";
3522
- limit: number;
3523
- window: ({
3524
- seconds: number;
3525
- } | {
3526
- minutes: number;
3527
- } | {
3528
- hours: number;
3529
- }) & ({
3530
- seconds: number;
3531
- } | {
3532
- minutes: number;
3533
- } | {
3534
- hours: number;
3535
- } | undefined);
3536
- } | {
3537
- type: "sliding-window";
3538
- limit: number;
3539
- window: ({
3540
- seconds: number;
3541
- } | {
3542
- minutes: number;
3543
- } | {
3544
- hours: number;
3545
- }) & ({
3546
- seconds: number;
3547
- } | {
3548
- minutes: number;
3549
- } | {
3550
- hours: number;
3551
- } | undefined);
3552
- } | undefined;
3553
- } | undefined;
3554
- retry?: {
3555
- maxAttempts?: number | undefined;
3556
- factor?: number | undefined;
3557
- minTimeoutInMs?: number | undefined;
3558
- maxTimeoutInMs?: number | undefined;
3559
- randomize?: boolean | undefined;
3560
- } | undefined;
3561
- machine?: {
3562
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3563
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3564
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3565
- } | undefined;
3566
- triggerSource?: string | undefined;
3567
- }>, "many">;
3568
- }, "strip", z.ZodTypeAny, {
3569
- packageVersion: string;
3570
- contentHash: string;
3571
- tasks: {
3572
- id: string;
3573
- filePath: string;
3574
- exportName: string;
3575
- queue?: {
3576
- name?: string | undefined;
3577
- concurrencyLimit?: number | undefined;
3578
- rateLimit?: {
3579
- type: "fixed-window";
3580
- limit: number;
3581
- window: ({
3582
- seconds: number;
3583
- } | {
3584
- minutes: number;
3585
- } | {
3586
- hours: number;
3587
- }) & ({
3588
- seconds: number;
3589
- } | {
3590
- minutes: number;
3591
- } | {
3592
- hours: number;
3593
- } | undefined);
3594
- } | {
3595
- type: "sliding-window";
3596
- limit: number;
3597
- window: ({
3598
- seconds: number;
3599
- } | {
3600
- minutes: number;
3601
- } | {
3602
- hours: number;
3603
- }) & ({
3604
- seconds: number;
3605
- } | {
3606
- minutes: number;
3607
- } | {
3608
- hours: number;
3609
- } | undefined);
3610
- } | undefined;
3611
- } | undefined;
3612
- retry?: {
3613
- maxAttempts?: number | undefined;
3614
- factor?: number | undefined;
3615
- minTimeoutInMs?: number | undefined;
3616
- maxTimeoutInMs?: number | undefined;
3617
- randomize?: boolean | undefined;
3618
- } | undefined;
3619
- machine?: {
3620
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3621
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3622
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3623
- } | undefined;
3624
- triggerSource?: string | undefined;
3625
- }[];
3626
- cliPackageVersion?: string | undefined;
3627
- }, {
3628
- packageVersion: string;
3629
- contentHash: string;
3630
- tasks: {
3631
- id: string;
3632
- filePath: string;
3633
- exportName: string;
3634
- queue?: {
3635
- name?: string | undefined;
3636
- concurrencyLimit?: number | undefined;
3637
- rateLimit?: {
3638
- type: "fixed-window";
3639
- limit: number;
3640
- window: ({
3641
- seconds: number;
3642
- } | {
3643
- minutes: number;
3644
- } | {
3645
- hours: number;
3646
- }) & ({
3647
- seconds: number;
3648
- } | {
3649
- minutes: number;
3650
- } | {
3651
- hours: number;
3652
- } | undefined);
3653
- } | {
3654
- type: "sliding-window";
3655
- limit: number;
3656
- window: ({
3657
- seconds: number;
3658
- } | {
3659
- minutes: number;
3660
- } | {
3661
- hours: number;
3662
- }) & ({
3663
- seconds: number;
3664
- } | {
3665
- minutes: number;
3666
- } | {
3667
- hours: number;
3668
- } | undefined);
3669
- } | undefined;
3670
- } | undefined;
3671
- retry?: {
3672
- maxAttempts?: number | undefined;
3673
- factor?: number | undefined;
3674
- minTimeoutInMs?: number | undefined;
3675
- maxTimeoutInMs?: number | undefined;
3676
- randomize?: boolean | undefined;
3677
- } | undefined;
3678
- machine?: {
3679
- cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
3680
- memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
3681
- preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
3682
- } | undefined;
3683
- triggerSource?: string | undefined;
3684
- }[];
3685
- cliPackageVersion?: string | undefined;
3686
- }>;
3687
- type BackgroundWorkerMetadata = z.infer<typeof BackgroundWorkerMetadata>;
3688
- declare const ImageDetailsMetadata: z.ZodObject<{
3689
- contentHash: z.ZodString;
3690
- imageTag: z.ZodString;
3691
- }, "strip", z.ZodTypeAny, {
3692
- contentHash: string;
3693
- imageTag: string;
3694
- }, {
3695
- contentHash: string;
3696
- imageTag: string;
3697
- }>;
3698
- type ImageDetailsMetadata = z.infer<typeof ImageDetailsMetadata>;
3699
-
3700
- declare const PRIMARY_VARIANT = "primary";
3701
- declare const Variant: z.ZodEnum<["primary"]>;
3702
- type Variant = z.infer<typeof Variant>;
3703
- declare const Accessory: z.ZodObject<{
3704
- items: z.ZodArray<z.ZodObject<{
3705
- text: z.ZodString;
3706
- variant: z.ZodOptional<z.ZodString>;
3707
- url: z.ZodOptional<z.ZodString>;
3708
- }, "strip", z.ZodTypeAny, {
3709
- text: string;
3710
- variant?: string | undefined;
3711
- url?: string | undefined;
3712
- }, {
3713
- text: string;
3714
- variant?: string | undefined;
3715
- url?: string | undefined;
3716
- }>, "many">;
3717
- style: z.ZodOptional<z.ZodEnum<["codepath"]>>;
3718
- }, "strip", z.ZodTypeAny, {
3719
- items: {
3720
- text: string;
3721
- variant?: string | undefined;
3722
- url?: string | undefined;
3723
- }[];
3724
- style?: "codepath" | undefined;
3725
- }, {
3726
- items: {
3727
- text: string;
3728
- variant?: string | undefined;
3729
- url?: string | undefined;
3730
- }[];
3731
- style?: "codepath" | undefined;
3732
- }>;
3733
- type Accessory = z.infer<typeof Accessory>;
3734
- declare const TaskEventStyle: z.ZodDefault<z.ZodObject<{
3735
- icon: z.ZodOptional<z.ZodString>;
3736
- variant: z.ZodOptional<z.ZodEnum<["primary"]>>;
3737
- accessory: z.ZodOptional<z.ZodObject<{
3738
- items: z.ZodArray<z.ZodObject<{
3739
- text: z.ZodString;
3740
- variant: z.ZodOptional<z.ZodString>;
3741
- url: z.ZodOptional<z.ZodString>;
3742
- }, "strip", z.ZodTypeAny, {
3743
- text: string;
3744
- variant?: string | undefined;
3745
- url?: string | undefined;
3746
- }, {
3747
- text: string;
3748
- variant?: string | undefined;
3749
- url?: string | undefined;
3750
- }>, "many">;
3751
- style: z.ZodOptional<z.ZodEnum<["codepath"]>>;
3752
- }, "strip", z.ZodTypeAny, {
3753
- items: {
3754
- text: string;
3755
- variant?: string | undefined;
3756
- url?: string | undefined;
3757
- }[];
3758
- style?: "codepath" | undefined;
3759
- }, {
3760
- items: {
3761
- text: string;
3762
- variant?: string | undefined;
3763
- url?: string | undefined;
3764
- }[];
3765
- style?: "codepath" | undefined;
3766
- }>>;
3767
- }, "strip", z.ZodTypeAny, {
3768
- icon?: string | undefined;
3769
- variant?: "primary" | undefined;
3770
- accessory?: {
3771
- items: {
3772
- text: string;
3773
- variant?: string | undefined;
3774
- url?: string | undefined;
3775
- }[];
3776
- style?: "codepath" | undefined;
3777
- } | undefined;
3778
- }, {
3779
- icon?: string | undefined;
3780
- variant?: "primary" | undefined;
3781
- accessory?: {
3782
- items: {
3783
- text: string;
3784
- variant?: string | undefined;
3785
- url?: string | undefined;
3786
- }[];
3787
- style?: "codepath" | undefined;
3788
- } | undefined;
3789
- }>>;
3790
- type TaskEventStyle = z.infer<typeof TaskEventStyle>;
3791
-
3792
- declare const stringPatternMatchers: readonly [z.ZodObject<{
3793
- $endsWith: z.ZodString;
3794
- }, "strip", z.ZodTypeAny, {
3795
- $endsWith: string;
3796
- }, {
3797
- $endsWith: string;
3798
- }>, z.ZodObject<{
3799
- $startsWith: z.ZodString;
3800
- }, "strip", z.ZodTypeAny, {
3801
- $startsWith: string;
3802
- }, {
3803
- $startsWith: string;
3804
- }>, z.ZodObject<{
3805
- $ignoreCaseEquals: z.ZodString;
3806
- }, "strip", z.ZodTypeAny, {
3807
- $ignoreCaseEquals: string;
3808
- }, {
3809
- $ignoreCaseEquals: string;
3810
- }>];
3811
- declare const EventMatcher: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">, z.ZodArray<z.ZodUnion<[z.ZodObject<{
3812
- $endsWith: z.ZodString;
3813
- }, "strip", z.ZodTypeAny, {
3814
- $endsWith: string;
3815
- }, {
3816
- $endsWith: string;
3817
- }>, z.ZodObject<{
3818
- $startsWith: z.ZodString;
3819
- }, "strip", z.ZodTypeAny, {
3820
- $startsWith: string;
3821
- }, {
3822
- $startsWith: string;
3823
- }>, z.ZodObject<{
3824
- $ignoreCaseEquals: z.ZodString;
3825
- }, "strip", z.ZodTypeAny, {
3826
- $ignoreCaseEquals: string;
3827
- }, {
3828
- $ignoreCaseEquals: string;
3829
- }>, z.ZodObject<{
3830
- $exists: z.ZodBoolean;
3831
- }, "strip", z.ZodTypeAny, {
3832
- $exists: boolean;
3833
- }, {
3834
- $exists: boolean;
3835
- }>, z.ZodObject<{
3836
- $isNull: z.ZodBoolean;
3837
- }, "strip", z.ZodTypeAny, {
3838
- $isNull: boolean;
3839
- }, {
3840
- $isNull: boolean;
3841
- }>, z.ZodObject<{
3842
- $anythingBut: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
3843
- }, "strip", z.ZodTypeAny, {
3844
- $anythingBut: string | number | boolean;
3845
- }, {
3846
- $anythingBut: string | number | boolean;
3847
- }>, z.ZodObject<{
3848
- $anythingBut: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>;
3849
- }, "strip", z.ZodTypeAny, {
3850
- $anythingBut: (string[] | number[] | boolean[]) & (string[] | number[] | boolean[] | undefined);
3851
- }, {
3852
- $anythingBut: (string[] | number[] | boolean[]) & (string[] | number[] | boolean[] | undefined);
3853
- }>, z.ZodObject<{
3854
- $gt: z.ZodNumber;
3855
- }, "strip", z.ZodTypeAny, {
3856
- $gt: number;
3857
- }, {
3858
- $gt: number;
3859
- }>, z.ZodObject<{
3860
- $lt: z.ZodNumber;
3861
- }, "strip", z.ZodTypeAny, {
3862
- $lt: number;
3863
- }, {
3864
- $lt: number;
3865
- }>, z.ZodObject<{
3866
- $gte: z.ZodNumber;
3867
- }, "strip", z.ZodTypeAny, {
3868
- $gte: number;
3869
- }, {
3870
- $gte: number;
3871
- }>, z.ZodObject<{
3872
- $lte: z.ZodNumber;
3873
- }, "strip", z.ZodTypeAny, {
3874
- $lte: number;
3875
- }, {
3876
- $lte: number;
3877
- }>, z.ZodObject<{
3878
- $between: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
3879
- }, "strip", z.ZodTypeAny, {
3880
- $between: [number, number];
3881
- }, {
3882
- $between: [number, number];
3883
- }>, z.ZodObject<{
3884
- $includes: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
3885
- }, "strip", z.ZodTypeAny, {
3886
- $includes: string | number | boolean;
3887
- }, {
3888
- $includes: string | number | boolean;
3889
- }>, z.ZodObject<{
3890
- $not: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
3891
- }, "strip", z.ZodTypeAny, {
3892
- $not: string | number | boolean;
3893
- }, {
3894
- $not: string | number | boolean;
3895
- }>]>, "many">]>;
3896
- type EventMatcher = z.infer<typeof EventMatcher>;
3897
- /** A filter for matching against data */
3898
- type EventFilter = {
3899
- [key: string]: EventMatcher | EventFilter;
3900
- };
3901
- declare const EventFilter: z.ZodType<EventFilter>;
3902
-
3903
- declare const FetchRetryHeadersStrategy: z.ZodObject<{
3904
- /** The `headers` strategy retries the request using info from the response headers. */
3905
- strategy: z.ZodLiteral<"headers">;
3906
- /** The header to use to determine the maximum number of times to retry the request. */
3907
- limitHeader: z.ZodString;
3908
- /** The header to use to determine the number of remaining retries. */
3909
- remainingHeader: z.ZodString;
3910
- /** The header to use to determine the time when the number of remaining retries will be reset. */
3911
- resetHeader: z.ZodString;
3912
- /** The event filter to use to determine if the request should be retried. */
3913
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
3914
- /** The format of the `resetHeader` value. */
3915
- resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
3916
- }, "strip", z.ZodTypeAny, {
3917
- strategy: "headers";
3918
- limitHeader: string;
3919
- remainingHeader: string;
3920
- resetHeader: string;
3921
- bodyFilter?: EventFilter | undefined;
3922
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
3923
- }, {
3924
- strategy: "headers";
3925
- limitHeader: string;
3926
- remainingHeader: string;
3927
- resetHeader: string;
3928
- bodyFilter?: EventFilter | undefined;
3929
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
3930
- }>;
3931
- type FetchRetryHeadersStrategy = z.infer<typeof FetchRetryHeadersStrategy>;
3932
- declare const FetchRetryBackoffStrategy: z.ZodObject<{
3933
- maxAttempts: z.ZodOptional<z.ZodNumber>;
3934
- factor: z.ZodOptional<z.ZodNumber>;
3935
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3936
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3937
- randomize: z.ZodOptional<z.ZodBoolean>;
3938
- strategy: z.ZodLiteral<"backoff">;
3939
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
3940
- }, "strip", z.ZodTypeAny, {
3941
- strategy: "backoff";
3942
- maxAttempts?: number | undefined;
3943
- factor?: number | undefined;
3944
- minTimeoutInMs?: number | undefined;
3945
- maxTimeoutInMs?: number | undefined;
3946
- randomize?: boolean | undefined;
3947
- bodyFilter?: EventFilter | undefined;
3948
- }, {
3949
- strategy: "backoff";
3950
- maxAttempts?: number | undefined;
3951
- factor?: number | undefined;
3952
- minTimeoutInMs?: number | undefined;
3953
- maxTimeoutInMs?: number | undefined;
3954
- randomize?: boolean | undefined;
3955
- bodyFilter?: EventFilter | undefined;
3956
- }>;
3957
- /** The `backoff` strategy retries the request with an exponential backoff. */
3958
- type FetchRetryBackoffStrategy = z.infer<typeof FetchRetryBackoffStrategy>;
3959
- declare const FetchRetryStrategy: z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
3960
- /** The `headers` strategy retries the request using info from the response headers. */
3961
- strategy: z.ZodLiteral<"headers">;
3962
- /** The header to use to determine the maximum number of times to retry the request. */
3963
- limitHeader: z.ZodString;
3964
- /** The header to use to determine the number of remaining retries. */
3965
- remainingHeader: z.ZodString;
3966
- /** The header to use to determine the time when the number of remaining retries will be reset. */
3967
- resetHeader: z.ZodString;
3968
- /** The event filter to use to determine if the request should be retried. */
3969
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
3970
- /** The format of the `resetHeader` value. */
3971
- resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
3972
- }, "strip", z.ZodTypeAny, {
3973
- strategy: "headers";
3974
- limitHeader: string;
3975
- remainingHeader: string;
3976
- resetHeader: string;
3977
- bodyFilter?: EventFilter | undefined;
3978
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
3979
- }, {
3980
- strategy: "headers";
3981
- limitHeader: string;
3982
- remainingHeader: string;
3983
- resetHeader: string;
3984
- bodyFilter?: EventFilter | undefined;
3985
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
3986
- }>, z.ZodObject<{
3987
- maxAttempts: z.ZodOptional<z.ZodNumber>;
3988
- factor: z.ZodOptional<z.ZodNumber>;
3989
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3990
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
3991
- randomize: z.ZodOptional<z.ZodBoolean>;
3992
- strategy: z.ZodLiteral<"backoff">;
3993
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
3994
- }, "strip", z.ZodTypeAny, {
3995
- strategy: "backoff";
3996
- maxAttempts?: number | undefined;
3997
- factor?: number | undefined;
3998
- minTimeoutInMs?: number | undefined;
3999
- maxTimeoutInMs?: number | undefined;
4000
- randomize?: boolean | undefined;
4001
- bodyFilter?: EventFilter | undefined;
4002
- }, {
4003
- strategy: "backoff";
4004
- maxAttempts?: number | undefined;
4005
- factor?: number | undefined;
4006
- minTimeoutInMs?: number | undefined;
4007
- maxTimeoutInMs?: number | undefined;
4008
- randomize?: boolean | undefined;
4009
- bodyFilter?: EventFilter | undefined;
4010
- }>]>;
4011
- type FetchRetryStrategy = z.infer<typeof FetchRetryStrategy>;
4012
- declare const FetchRetryByStatusOptions: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
4013
- /** The `headers` strategy retries the request using info from the response headers. */
4014
- strategy: z.ZodLiteral<"headers">;
4015
- /** The header to use to determine the maximum number of times to retry the request. */
4016
- limitHeader: z.ZodString;
4017
- /** The header to use to determine the number of remaining retries. */
4018
- remainingHeader: z.ZodString;
4019
- /** The header to use to determine the time when the number of remaining retries will be reset. */
4020
- resetHeader: z.ZodString;
4021
- /** The event filter to use to determine if the request should be retried. */
4022
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
4023
- /** The format of the `resetHeader` value. */
4024
- resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
4025
- }, "strip", z.ZodTypeAny, {
4026
- strategy: "headers";
4027
- limitHeader: string;
4028
- remainingHeader: string;
4029
- resetHeader: string;
4030
- bodyFilter?: EventFilter | undefined;
4031
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
4032
- }, {
4033
- strategy: "headers";
4034
- limitHeader: string;
4035
- remainingHeader: string;
4036
- resetHeader: string;
4037
- bodyFilter?: EventFilter | undefined;
4038
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
4039
- }>, z.ZodObject<{
4040
- maxAttempts: z.ZodOptional<z.ZodNumber>;
4041
- factor: z.ZodOptional<z.ZodNumber>;
4042
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4043
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4044
- randomize: z.ZodOptional<z.ZodBoolean>;
4045
- strategy: z.ZodLiteral<"backoff">;
4046
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
4047
- }, "strip", z.ZodTypeAny, {
4048
- strategy: "backoff";
4049
- maxAttempts?: number | undefined;
4050
- factor?: number | undefined;
4051
- minTimeoutInMs?: number | undefined;
4052
- maxTimeoutInMs?: number | undefined;
4053
- randomize?: boolean | undefined;
4054
- bodyFilter?: EventFilter | undefined;
4055
- }, {
4056
- strategy: "backoff";
4057
- maxAttempts?: number | undefined;
4058
- factor?: number | undefined;
4059
- minTimeoutInMs?: number | undefined;
4060
- maxTimeoutInMs?: number | undefined;
4061
- randomize?: boolean | undefined;
4062
- bodyFilter?: EventFilter | undefined;
4063
- }>]>>;
4064
- /** An object where the key is a status code pattern and the value is a retrying strategy. Supported patterns are:
4065
- - Specific status codes: 429
4066
- - Ranges: 500-599
4067
- - Wildcards: 2xx, 3xx, 4xx, 5xx
4068
- */
4069
- type FetchRetryByStatusOptions = Prettify<z.infer<typeof FetchRetryByStatusOptions>>;
4070
- declare const FetchTimeoutOptions: z.ZodObject<{
4071
- /** The maximum time to wait for the request to complete. */
4072
- durationInMs: z.ZodOptional<z.ZodNumber>;
4073
- retry: z.ZodOptional<z.ZodObject<{
4074
- maxAttempts: z.ZodOptional<z.ZodNumber>;
4075
- /** The retrying strategy for specific status codes. */
4076
- factor: z.ZodOptional<z.ZodNumber>; /**
4077
- * The retrying strategy for connection errors.
4078
- */
4079
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4080
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4081
- randomize: z.ZodOptional<z.ZodBoolean>;
4082
- }, "strip", z.ZodTypeAny, {
4083
- maxAttempts?: number | undefined;
4084
- factor?: number | undefined;
4085
- minTimeoutInMs?: number | undefined;
4086
- maxTimeoutInMs?: number | undefined;
4087
- randomize?: boolean | undefined;
4088
- }, {
4089
- maxAttempts?: number | undefined;
4090
- factor?: number | undefined;
4091
- minTimeoutInMs?: number | undefined;
4092
- maxTimeoutInMs?: number | undefined;
4093
- randomize?: boolean | undefined;
4094
- }>>;
4095
- }, "strip", z.ZodTypeAny, {
4096
- durationInMs?: number | undefined;
4097
- retry?: {
4098
- maxAttempts?: number | undefined;
4099
- factor?: number | undefined;
4100
- minTimeoutInMs?: number | undefined;
4101
- maxTimeoutInMs?: number | undefined;
4102
- randomize?: boolean | undefined;
4103
- } | undefined;
4104
- }, {
4105
- durationInMs?: number | undefined;
4106
- retry?: {
4107
- maxAttempts?: number | undefined;
4108
- factor?: number | undefined;
4109
- minTimeoutInMs?: number | undefined;
4110
- maxTimeoutInMs?: number | undefined;
4111
- randomize?: boolean | undefined;
4112
- } | undefined;
4113
- }>;
4114
- type FetchTimeoutOptions = z.infer<typeof FetchTimeoutOptions>;
4115
- declare const FetchRetryOptions: z.ZodObject<{
4116
- /** The retrying strategy for specific status codes. */
4117
- byStatus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
4118
- /** The `headers` strategy retries the request using info from the response headers. */
4119
- strategy: z.ZodLiteral<"headers">;
4120
- /** The header to use to determine the maximum number of times to retry the request. */
4121
- limitHeader: z.ZodString;
4122
- /** The header to use to determine the number of remaining retries. */
4123
- remainingHeader: z.ZodString;
4124
- /** The header to use to determine the time when the number of remaining retries will be reset. */
4125
- resetHeader: z.ZodString;
4126
- /** The event filter to use to determine if the request should be retried. */
4127
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
4128
- /** The format of the `resetHeader` value. */
4129
- resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
4130
- }, "strip", z.ZodTypeAny, {
4131
- strategy: "headers";
4132
- limitHeader: string;
4133
- remainingHeader: string;
4134
- resetHeader: string;
4135
- bodyFilter?: EventFilter | undefined;
4136
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
4137
- }, {
4138
- strategy: "headers";
4139
- limitHeader: string;
4140
- remainingHeader: string;
4141
- resetHeader: string;
4142
- bodyFilter?: EventFilter | undefined;
4143
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
4144
- }>, z.ZodObject<{
4145
- maxAttempts: z.ZodOptional<z.ZodNumber>;
4146
- factor: z.ZodOptional<z.ZodNumber>;
4147
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4148
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4149
- randomize: z.ZodOptional<z.ZodBoolean>;
4150
- strategy: z.ZodLiteral<"backoff">;
4151
- bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
4152
- }, "strip", z.ZodTypeAny, {
4153
- strategy: "backoff";
4154
- maxAttempts?: number | undefined;
4155
- factor?: number | undefined;
4156
- minTimeoutInMs?: number | undefined;
4157
- maxTimeoutInMs?: number | undefined;
4158
- randomize?: boolean | undefined;
4159
- bodyFilter?: EventFilter | undefined;
4160
- }, {
4161
- strategy: "backoff";
4162
- maxAttempts?: number | undefined;
4163
- factor?: number | undefined;
4164
- minTimeoutInMs?: number | undefined;
4165
- maxTimeoutInMs?: number | undefined;
4166
- randomize?: boolean | undefined;
4167
- bodyFilter?: EventFilter | undefined;
4168
- }>]>>>;
4169
- /** The timeout options for the request. */
4170
- timeout: z.ZodOptional<z.ZodObject<{
4171
- maxAttempts: z.ZodOptional<z.ZodNumber>;
4172
- /** The retrying strategy for specific status codes. */
4173
- factor: z.ZodOptional<z.ZodNumber>; /**
4174
- * The retrying strategy for connection errors.
4175
- */
4176
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4177
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4178
- randomize: z.ZodOptional<z.ZodBoolean>;
4179
- }, "strip", z.ZodTypeAny, {
4180
- maxAttempts?: number | undefined;
4181
- factor?: number | undefined;
4182
- minTimeoutInMs?: number | undefined;
4183
- maxTimeoutInMs?: number | undefined;
4184
- randomize?: boolean | undefined;
4185
- }, {
4186
- maxAttempts?: number | undefined;
4187
- factor?: number | undefined;
4188
- minTimeoutInMs?: number | undefined;
4189
- maxTimeoutInMs?: number | undefined;
4190
- randomize?: boolean | undefined;
4191
- }>>;
4192
- /**
4193
- * The retrying strategy for connection errors.
4194
- */
4195
- connectionError: z.ZodOptional<z.ZodObject<{
4196
- maxAttempts: z.ZodOptional<z.ZodNumber>;
4197
- /** The retrying strategy for specific status codes. */
4198
- factor: z.ZodOptional<z.ZodNumber>; /**
4199
- * The retrying strategy for connection errors.
4200
- */
4201
- minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4202
- maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
4203
- randomize: z.ZodOptional<z.ZodBoolean>;
4204
- }, "strip", z.ZodTypeAny, {
4205
- maxAttempts?: number | undefined;
4206
- factor?: number | undefined;
4207
- minTimeoutInMs?: number | undefined;
4208
- maxTimeoutInMs?: number | undefined;
4209
- randomize?: boolean | undefined;
4210
- }, {
4211
- maxAttempts?: number | undefined;
4212
- factor?: number | undefined;
4213
- minTimeoutInMs?: number | undefined;
4214
- maxTimeoutInMs?: number | undefined;
4215
- randomize?: boolean | undefined;
4216
- }>>;
4217
- }, "strip", z.ZodTypeAny, {
4218
- byStatus?: Record<string, {
4219
- strategy: "headers";
4220
- limitHeader: string;
4221
- remainingHeader: string;
4222
- resetHeader: string;
4223
- bodyFilter?: EventFilter | undefined;
4224
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
4225
- } | {
4226
- strategy: "backoff";
4227
- maxAttempts?: number | undefined;
4228
- factor?: number | undefined;
4229
- minTimeoutInMs?: number | undefined;
4230
- maxTimeoutInMs?: number | undefined;
4231
- randomize?: boolean | undefined;
4232
- bodyFilter?: EventFilter | undefined;
4233
- }> | undefined;
4234
- timeout?: {
4235
- maxAttempts?: number | undefined;
4236
- factor?: number | undefined;
4237
- minTimeoutInMs?: number | undefined;
4238
- maxTimeoutInMs?: number | undefined;
4239
- randomize?: boolean | undefined;
4240
- } | undefined;
4241
- connectionError?: {
4242
- maxAttempts?: number | undefined;
4243
- factor?: number | undefined;
4244
- minTimeoutInMs?: number | undefined;
4245
- maxTimeoutInMs?: number | undefined;
4246
- randomize?: boolean | undefined;
4247
- } | undefined;
4248
- }, {
4249
- byStatus?: Record<string, {
4250
- strategy: "headers";
4251
- limitHeader: string;
4252
- remainingHeader: string;
4253
- resetHeader: string;
4254
- bodyFilter?: EventFilter | undefined;
4255
- resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
4256
- } | {
4257
- strategy: "backoff";
4258
- maxAttempts?: number | undefined;
4259
- factor?: number | undefined;
4260
- minTimeoutInMs?: number | undefined;
4261
- maxTimeoutInMs?: number | undefined;
4262
- randomize?: boolean | undefined;
4263
- bodyFilter?: EventFilter | undefined;
4264
- }> | undefined;
4265
- timeout?: {
4266
- maxAttempts?: number | undefined;
4267
- factor?: number | undefined;
4268
- minTimeoutInMs?: number | undefined;
4269
- maxTimeoutInMs?: number | undefined;
4270
- randomize?: boolean | undefined;
4271
- } | undefined;
4272
- connectionError?: {
4273
- maxAttempts?: number | undefined;
4274
- factor?: number | undefined;
4275
- minTimeoutInMs?: number | undefined;
4276
- maxTimeoutInMs?: number | undefined;
4277
- randomize?: boolean | undefined;
4278
- } | undefined;
4279
- }>;
4280
- type FetchRetryOptions = Prettify<z.infer<typeof FetchRetryOptions>>;
4281
-
4282
- declare const ExceptionEventProperties: z.ZodObject<{
4283
- type: z.ZodOptional<z.ZodString>;
4284
- message: z.ZodOptional<z.ZodString>;
4285
- stacktrace: z.ZodOptional<z.ZodString>;
4286
- }, "strip", z.ZodTypeAny, {
4287
- type?: string | undefined;
4288
- message?: string | undefined;
4289
- stacktrace?: string | undefined;
4290
- }, {
4291
- type?: string | undefined;
4292
- message?: string | undefined;
4293
- stacktrace?: string | undefined;
4294
- }>;
4295
- type ExceptionEventProperties = z.infer<typeof ExceptionEventProperties>;
4296
- declare const ExceptionSpanEvent: z.ZodObject<{
4297
- name: z.ZodLiteral<"exception">;
4298
- time: z.ZodDate;
4299
- properties: z.ZodObject<{
4300
- exception: z.ZodObject<{
4301
- type: z.ZodOptional<z.ZodString>;
4302
- message: z.ZodOptional<z.ZodString>;
4303
- stacktrace: z.ZodOptional<z.ZodString>;
4304
- }, "strip", z.ZodTypeAny, {
4305
- type?: string | undefined;
4306
- message?: string | undefined;
4307
- stacktrace?: string | undefined;
4308
- }, {
4309
- type?: string | undefined;
4310
- message?: string | undefined;
4311
- stacktrace?: string | undefined;
4312
- }>;
4313
- }, "strip", z.ZodTypeAny, {
4314
- exception: {
4315
- type?: string | undefined;
4316
- message?: string | undefined;
4317
- stacktrace?: string | undefined;
4318
- };
4319
- }, {
4320
- exception: {
4321
- type?: string | undefined;
4322
- message?: string | undefined;
4323
- stacktrace?: string | undefined;
4324
- };
4325
- }>;
4326
- }, "strip", z.ZodTypeAny, {
4327
- name: "exception";
4328
- time: Date;
4329
- properties: {
4330
- exception: {
4331
- type?: string | undefined;
4332
- message?: string | undefined;
4333
- stacktrace?: string | undefined;
4334
- };
4335
- };
4336
- }, {
4337
- name: "exception";
4338
- time: Date;
4339
- properties: {
4340
- exception: {
4341
- type?: string | undefined;
4342
- message?: string | undefined;
4343
- stacktrace?: string | undefined;
4344
- };
4345
- };
4346
- }>;
4347
- type ExceptionSpanEvent = z.infer<typeof ExceptionSpanEvent>;
4348
- declare const CancellationSpanEvent: z.ZodObject<{
4349
- name: z.ZodLiteral<"cancellation">;
4350
- time: z.ZodDate;
4351
- properties: z.ZodObject<{
4352
- reason: z.ZodString;
4353
- }, "strip", z.ZodTypeAny, {
4354
- reason: string;
4355
- }, {
4356
- reason: string;
4357
- }>;
4358
- }, "strip", z.ZodTypeAny, {
4359
- name: "cancellation";
4360
- time: Date;
4361
- properties: {
4362
- reason: string;
4363
- };
4364
- }, {
4365
- name: "cancellation";
4366
- time: Date;
4367
- properties: {
4368
- reason: string;
4369
- };
4370
- }>;
4371
- type CancellationSpanEvent = z.infer<typeof CancellationSpanEvent>;
4372
- declare const OtherSpanEvent: z.ZodObject<{
4373
- name: z.ZodString;
4374
- time: z.ZodDate;
4375
- properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
4376
- }, "strip", z.ZodTypeAny, {
4377
- name: string;
4378
- time: Date;
4379
- properties: Record<string, unknown>;
4380
- }, {
4381
- name: string;
4382
- time: Date;
4383
- properties: Record<string, unknown>;
4384
- }>;
4385
- type OtherSpanEvent = z.infer<typeof OtherSpanEvent>;
4386
- declare const SpanEvent: z.ZodUnion<[z.ZodObject<{
4387
- name: z.ZodLiteral<"exception">;
4388
- time: z.ZodDate;
4389
- properties: z.ZodObject<{
4390
- exception: z.ZodObject<{
4391
- type: z.ZodOptional<z.ZodString>;
4392
- message: z.ZodOptional<z.ZodString>;
4393
- stacktrace: z.ZodOptional<z.ZodString>;
4394
- }, "strip", z.ZodTypeAny, {
4395
- type?: string | undefined;
4396
- message?: string | undefined;
4397
- stacktrace?: string | undefined;
4398
- }, {
4399
- type?: string | undefined;
4400
- message?: string | undefined;
4401
- stacktrace?: string | undefined;
4402
- }>;
4403
- }, "strip", z.ZodTypeAny, {
4404
- exception: {
4405
- type?: string | undefined;
4406
- message?: string | undefined;
4407
- stacktrace?: string | undefined;
4408
- };
4409
- }, {
4410
- exception: {
4411
- type?: string | undefined;
4412
- message?: string | undefined;
4413
- stacktrace?: string | undefined;
4414
- };
4415
- }>;
4416
- }, "strip", z.ZodTypeAny, {
4417
- name: "exception";
4418
- time: Date;
4419
- properties: {
4420
- exception: {
4421
- type?: string | undefined;
4422
- message?: string | undefined;
4423
- stacktrace?: string | undefined;
4424
- };
4425
- };
4426
- }, {
4427
- name: "exception";
4428
- time: Date;
4429
- properties: {
4430
- exception: {
4431
- type?: string | undefined;
4432
- message?: string | undefined;
4433
- stacktrace?: string | undefined;
4434
- };
4435
- };
4436
- }>, z.ZodObject<{
4437
- name: z.ZodLiteral<"cancellation">;
4438
- time: z.ZodDate;
4439
- properties: z.ZodObject<{
4440
- reason: z.ZodString;
4441
- }, "strip", z.ZodTypeAny, {
4442
- reason: string;
4443
- }, {
4444
- reason: string;
4445
- }>;
4446
- }, "strip", z.ZodTypeAny, {
4447
- name: "cancellation";
4448
- time: Date;
4449
- properties: {
4450
- reason: string;
4451
- };
4452
- }, {
4453
- name: "cancellation";
4454
- time: Date;
4455
- properties: {
4456
- reason: string;
4457
- };
4458
- }>, z.ZodObject<{
4459
- name: z.ZodString;
4460
- time: z.ZodDate;
4461
- properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
4462
- }, "strip", z.ZodTypeAny, {
4463
- name: string;
4464
- time: Date;
4465
- properties: Record<string, unknown>;
4466
- }, {
4467
- name: string;
4468
- time: Date;
4469
- properties: Record<string, unknown>;
4470
- }>]>;
4471
- type SpanEvent = z.infer<typeof SpanEvent>;
4472
- declare const SpanEvents: z.ZodArray<z.ZodUnion<[z.ZodObject<{
4473
- name: z.ZodLiteral<"exception">;
4474
- time: z.ZodDate;
4475
- properties: z.ZodObject<{
4476
- exception: z.ZodObject<{
4477
- type: z.ZodOptional<z.ZodString>;
4478
- message: z.ZodOptional<z.ZodString>;
4479
- stacktrace: z.ZodOptional<z.ZodString>;
4480
- }, "strip", z.ZodTypeAny, {
4481
- type?: string | undefined;
4482
- message?: string | undefined;
4483
- stacktrace?: string | undefined;
4484
- }, {
4485
- type?: string | undefined;
4486
- message?: string | undefined;
4487
- stacktrace?: string | undefined;
4488
- }>;
4489
- }, "strip", z.ZodTypeAny, {
4490
- exception: {
4491
- type?: string | undefined;
4492
- message?: string | undefined;
4493
- stacktrace?: string | undefined;
4494
- };
4495
- }, {
4496
- exception: {
4497
- type?: string | undefined;
4498
- message?: string | undefined;
4499
- stacktrace?: string | undefined;
4500
- };
4501
- }>;
4502
- }, "strip", z.ZodTypeAny, {
4503
- name: "exception";
4504
- time: Date;
4505
- properties: {
4506
- exception: {
4507
- type?: string | undefined;
4508
- message?: string | undefined;
4509
- stacktrace?: string | undefined;
4510
- };
4511
- };
4512
- }, {
4513
- name: "exception";
4514
- time: Date;
4515
- properties: {
4516
- exception: {
4517
- type?: string | undefined;
4518
- message?: string | undefined;
4519
- stacktrace?: string | undefined;
4520
- };
4521
- };
4522
- }>, z.ZodObject<{
4523
- name: z.ZodLiteral<"cancellation">;
4524
- time: z.ZodDate;
4525
- properties: z.ZodObject<{
4526
- reason: z.ZodString;
4527
- }, "strip", z.ZodTypeAny, {
4528
- reason: string;
4529
- }, {
4530
- reason: string;
4531
- }>;
4532
- }, "strip", z.ZodTypeAny, {
4533
- name: "cancellation";
4534
- time: Date;
4535
- properties: {
4536
- reason: string;
4537
- };
4538
- }, {
4539
- name: "cancellation";
4540
- time: Date;
4541
- properties: {
4542
- reason: string;
4543
- };
4544
- }>, z.ZodObject<{
4545
- name: z.ZodString;
4546
- time: z.ZodDate;
4547
- properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
4548
- }, "strip", z.ZodTypeAny, {
4549
- name: string;
4550
- time: Date;
4551
- properties: Record<string, unknown>;
4552
- }, {
4553
- name: string;
4554
- time: Date;
4555
- properties: Record<string, unknown>;
4556
- }>]>, "many">;
4557
- type SpanEvents = z.infer<typeof SpanEvents>;
4558
- declare function isExceptionSpanEvent(event: SpanEvent): event is ExceptionSpanEvent;
4559
- declare function isCancellationSpanEvent(event: SpanEvent): event is CancellationSpanEvent;
4560
- declare const SpanMessagingEvent: z.ZodObject<{
4561
- system: z.ZodOptional<z.ZodString>;
4562
- client_id: z.ZodOptional<z.ZodString>;
4563
- operation: z.ZodEnum<["publish", "create", "receive", "deliver"]>;
4564
- message: z.ZodAny;
4565
- destination: z.ZodOptional<z.ZodString>;
4566
- }, "strip", z.ZodTypeAny, {
4567
- operation: "create" | "publish" | "receive" | "deliver";
4568
- system?: string | undefined;
4569
- client_id?: string | undefined;
4570
- message?: any;
4571
- destination?: string | undefined;
4572
- }, {
4573
- operation: "create" | "publish" | "receive" | "deliver";
4574
- system?: string | undefined;
4575
- client_id?: string | undefined;
4576
- message?: any;
4577
- destination?: string | undefined;
4578
- }>;
4579
- type SpanMessagingEvent = z.infer<typeof SpanMessagingEvent>;
4580
-
4581
23
  interface ImportEnvironmentVariablesParams {
4582
24
  /**
4583
25
  * The variables to be imported. If a variable with the same key already exists, it will be overwritten when `override` is `true`.
@@ -4636,7 +78,7 @@ declare class ApiClient {
4636
78
  presignedUrl: string;
4637
79
  }>;
4638
80
  retrieveRun(runId: string): ApiPromise<{
4639
- status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE";
81
+ status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
4640
82
  id: string;
4641
83
  isTest: boolean;
4642
84
  createdAt: Date;
@@ -4679,6 +121,9 @@ declare class ApiClient {
4679
121
  version?: string | undefined;
4680
122
  startedAt?: Date | undefined;
4681
123
  finishedAt?: Date | undefined;
124
+ delayedUntil?: Date | undefined;
125
+ ttl?: string | undefined;
126
+ expiredAt?: Date | undefined;
4682
127
  }>;
4683
128
  listRuns(query?: ListRunsQueryParams): CursorPagePromise<typeof ListRunResponseItem>;
4684
129
  listProjectRuns(projectRef: string, query?: ListProjectRunsQueryParams): CursorPagePromise<typeof ListRunResponseItem>;
@@ -4688,6 +133,54 @@ declare class ApiClient {
4688
133
  cancelRun(runId: string): ApiPromise<{
4689
134
  id: string;
4690
135
  }>;
136
+ rescheduleRun(runId: string, body: RescheduleRunRequestBody): ApiPromise<{
137
+ status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
138
+ id: string;
139
+ isTest: boolean;
140
+ createdAt: Date;
141
+ attempts: ({
142
+ status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
143
+ id: string;
144
+ createdAt: Date;
145
+ updatedAt: Date;
146
+ startedAt?: Date | undefined;
147
+ completedAt?: Date | undefined;
148
+ error?: {
149
+ message: string;
150
+ name?: string | undefined;
151
+ stackTrace?: string | undefined;
152
+ } | undefined;
153
+ } | undefined)[];
154
+ updatedAt: Date;
155
+ taskIdentifier: string;
156
+ isQueued: boolean;
157
+ isExecuting: boolean;
158
+ isCompleted: boolean;
159
+ isSuccess: boolean;
160
+ isFailed: boolean;
161
+ isCancelled: boolean;
162
+ payload?: any;
163
+ payloadPresignedUrl?: string | undefined;
164
+ output?: any;
165
+ outputPresignedUrl?: string | undefined;
166
+ schedule?: {
167
+ id: string;
168
+ generator: {
169
+ type: "CRON";
170
+ expression: string;
171
+ description: string;
172
+ };
173
+ externalId?: string | undefined;
174
+ deduplicationKey?: string | undefined;
175
+ } | undefined;
176
+ idempotencyKey?: string | undefined;
177
+ version?: string | undefined;
178
+ startedAt?: Date | undefined;
179
+ finishedAt?: Date | undefined;
180
+ delayedUntil?: Date | undefined;
181
+ ttl?: string | undefined;
182
+ expiredAt?: Date | undefined;
183
+ }>;
4691
184
  createSchedule(options: CreateScheduleOptions): ApiPromise<{
4692
185
  id: string;
4693
186
  task: string;
@@ -5157,4 +650,4 @@ declare function createPacketAttributes(packet: IOPacket, dataKey: string, dataT
5157
650
  declare function createPacketAttributesAsJson(data: any, dataType: string): Promise<Attributes>;
5158
651
  declare function prettyPrintPacket(rawData: any, dataType?: string): Promise<string>;
5159
652
 
5160
- export { Accessory, ApiClient, type ApiClientConfiguration, ApiPromise, AttemptStatus, BackgroundWorkerMetadata, BackgroundWorkerProperties, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, type CreateAuthorizationCodeResponse, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, type CreateEnvironmentVariableParams, CreateEnvironmentVariableRequestBody, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, CursorPageParams, CursorPagePromise, DeletedScheduleObject, DeploymentErrorData, EnvironmentVariable, EnvironmentVariableResponseBody, EnvironmentVariableValue, EnvironmentVariables, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, type GetPersonalAccessTokenRequest, GetPersonalAccessTokenRequestSchema, type GetPersonalAccessTokenResponse, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, type IOPacket, ImageDetailsMetadata, type ImportEnvironmentVariablesParams, ImportEnvironmentVariablesRequestBody, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, type ListProjectRunsQueryParams, ListRunResponse, ListRunResponseItem, type ListRunsQueryParams, ListScheduleOptions, ListSchedulesResult, NULL_SENTINEL, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OffsetLimitPagePromise, OtherSpanEvent, PRIMARY_VARIANT, Prettify, ReplayRunResponse, RetrieveRunResponse, RetryOptions, RunEnvironmentDetails, RunScheduleDetails, RunStatus, ScheduleGenerator, ScheduleObject, ScheduledTaskPayload, SemanticInternalAttributes, SerializedError, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskFileMetadata, TaskMetadataWithFilePath, TaskMetadataWithFunctions, TaskResource, TaskRunContext, TaskRunError, TaskRunExecutionResult, TimezonesResult, type TriggerOptions, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, type UpdateEnvironmentVariableParams, UpdateEnvironmentVariableRequestBody, UpdateScheduleOptions, Variant, type WhoAmIResponse, WhoAmIResponseSchema, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createJsonErrorObject, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, flattenAttributes, groupTaskMetadataIssuesByTask, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logger, omit, packetRequiresOffloading, parseError, parsePacket, prettyPrintPacket, primitiveValueOrflattenedAttributes, runtime, stringPatternMatchers, stringifyIO, taskCatalog, taskContext, unflattenAttributes };
653
+ export { Accessory, ApiClient, type ApiClientConfiguration, ApiPromise, BackgroundWorkerProperties, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, type CreateEnvironmentVariableParams, CreateEnvironmentVariableRequestBody, CreateScheduleOptions, CursorPageParams, CursorPagePromise, type IOPacket, type ImportEnvironmentVariablesParams, type ListProjectRunsQueryParams, ListRunResponseItem, type ListRunsQueryParams, ListScheduleOptions, NULL_SENTINEL, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OffsetLimitPagePromise, RescheduleRunRequestBody, RetryOptions, RunStatus, SemanticInternalAttributes, SerializedError, TaskFileMetadata, TaskMetadataWithFilePath, TaskMetadataWithFunctions, TaskRunContext, TaskRunError, TaskRunExecutionResult, type TriggerOptions, TriggerTaskRequestBody, TriggerTracer, type UpdateEnvironmentVariableParams, UpdateEnvironmentVariableRequestBody, UpdateScheduleOptions, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createJsonErrorObject, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, flattenAttributes, groupTaskMetadataIssuesByTask, imposeAttributeLimits, logger, omit, packetRequiresOffloading, parseError, parsePacket, prettyPrintPacket, primitiveValueOrflattenedAttributes, runtime, stringifyIO, taskCatalog, taskContext, unflattenAttributes };