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

package/dist/v3/schemas/index.d.ts

@@ -0,0 +1,4633 @@
+import { z } from 'zod';
+export { B as BatchTaskRunExecutionResult, f as MachineConfig, d as MachineCpu, e as MachineMemory, g as MachinePreset, M as MachinePresetName, m as TaskRun, h as TaskRunBuiltInError, a as TaskRunContext, i as TaskRunCustomErrorObject, c as TaskRunError, k as TaskRunErrorCodes, b as TaskRunExecution, o as TaskRunExecutionAttempt, t as TaskRunExecutionBatch, p as TaskRunExecutionEnvironment, q as TaskRunExecutionOrganization, r as TaskRunExecutionProject, s as TaskRunExecutionQueue, T as TaskRunExecutionResult, 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';
+export { c as BackgroundWorkerClientMessages, B as BackgroundWorkerProperties, 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';
+import { P as Prettify } from '../../schemas-Sb0sJcEt.js';
+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, i as ResolvedConfig, R as RetryOptions, S as SlidingWindowRateLimit, T as TaskFileMetadata, b as TaskMetadata, a as TaskMetadataWithFilePath, j as TaskRunExecutionLazyAttemptPayload, c as TaskRunExecutionPayload, W as WaitReason } from '../../schemas-Sb0sJcEt.js';
+
+declare const CreateAuthorizationCodeResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+    authorizationCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    authorizationCode: string;
+}, {
+    url: string;
+    authorizationCode: string;
+}>;
+type CreateAuthorizationCodeResponse = z.infer<typeof CreateAuthorizationCodeResponseSchema>;
+declare const GetPersonalAccessTokenRequestSchema: z.ZodObject<{
+    authorizationCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    authorizationCode: string;
+}, {
+    authorizationCode: string;
+}>;
+type GetPersonalAccessTokenRequest = z.infer<typeof GetPersonalAccessTokenRequestSchema>;
+declare const GetPersonalAccessTokenResponseSchema: z.ZodObject<{
+    token: z.ZodNullable<z.ZodObject<{
+        token: z.ZodString;
+        obfuscatedToken: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+        obfuscatedToken: string;
+    }, {
+        token: string;
+        obfuscatedToken: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    token: {
+        token: string;
+        obfuscatedToken: string;
+    } | null;
+}, {
+    token: {
+        token: string;
+        obfuscatedToken: string;
+    } | null;
+}>;
+type GetPersonalAccessTokenResponse = z.infer<typeof GetPersonalAccessTokenResponseSchema>;
+
+declare const WhoAmIResponseSchema: z.ZodObject<{
+    userId: z.ZodString;
+    email: z.ZodString;
+    dashboardUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    email: string;
+    dashboardUrl: string;
+}, {
+    userId: string;
+    email: string;
+    dashboardUrl: string;
+}>;
+type WhoAmIResponse = z.infer<typeof WhoAmIResponseSchema>;
+declare const GetProjectResponseBody: z.ZodObject<{
+    id: z.ZodString;
+    externalRef: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    createdAt: z.ZodDate;
+    organization: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        slug: z.ZodString;
+        createdAt: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    }, {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: Date;
+    name: string;
+    slug: string;
+    organization: {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    };
+    externalRef: string;
+}, {
+    id: string;
+    createdAt: Date;
+    name: string;
+    slug: string;
+    organization: {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    };
+    externalRef: string;
+}>;
+type GetProjectResponseBody = z.infer<typeof GetProjectResponseBody>;
+declare const GetProjectsResponseBody: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    externalRef: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    createdAt: z.ZodDate;
+    organization: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        slug: z.ZodString;
+        createdAt: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    }, {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: Date;
+    name: string;
+    slug: string;
+    organization: {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    };
+    externalRef: string;
+}, {
+    id: string;
+    createdAt: Date;
+    name: string;
+    slug: string;
+    organization: {
+        id: string;
+        createdAt: Date;
+        slug: string;
+        title: string;
+    };
+    externalRef: string;
+}>, "many">;
+type GetProjectsResponseBody = z.infer<typeof GetProjectsResponseBody>;
+declare const GetProjectEnvResponse: z.ZodObject<{
+    apiKey: z.ZodString;
+    name: z.ZodString;
+    apiUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    apiKey: string;
+    apiUrl: string;
+}, {
+    name: string;
+    apiKey: string;
+    apiUrl: string;
+}>;
+type GetProjectEnvResponse = z.infer<typeof GetProjectEnvResponse>;
+declare const CreateBackgroundWorkerRequestBody: z.ZodObject<{
+    localOnly: z.ZodBoolean;
+    metadata: z.ZodObject<{
+        packageVersion: z.ZodString;
+        contentHash: z.ZodString;
+        cliPackageVersion: z.ZodOptional<z.ZodString>;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filePath: z.ZodString;
+            exportName: z.ZodString;
+            queue: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                concurrencyLimit: z.ZodOptional<z.ZodNumber>;
+                rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                    type: z.ZodLiteral<"fixed-window">;
+                    limit: z.ZodNumber;
+                    window: z.ZodUnion<[z.ZodObject<{
+                        seconds: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        seconds: number;
+                    }, {
+                        seconds: number;
+                    }>, z.ZodObject<{
+                        minutes: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        minutes: number;
+                    }, {
+                        minutes: number;
+                    }>, z.ZodObject<{
+                        hours: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        hours: number;
+                    }, {
+                        hours: number;
+                    }>]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }, {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"sliding-window">;
+                    limit: z.ZodNumber;
+                    window: z.ZodUnion<[z.ZodObject<{
+                        seconds: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        seconds: number;
+                    }, {
+                        seconds: number;
+                    }>, z.ZodObject<{
+                        minutes: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        minutes: number;
+                    }, {
+                        minutes: number;
+                    }>, z.ZodObject<{
+                        hours: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        hours: number;
+                    }, {
+                        hours: number;
+                    }>]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }, {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }>]>>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            }, {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            }>>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                factor: z.ZodOptional<z.ZodNumber>;
+                minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+                maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+                randomize: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            }, {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            }>>;
+            machine: z.ZodOptional<z.ZodObject<{
+                cpu: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
+                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>]>>;
+                preset: z.ZodOptional<z.ZodEnum<["micro", "small-1x", "small-2x", "medium-1x", "medium-2x", "large-1x", "large-2x"]>>;
+            }, "strip", z.ZodTypeAny, {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            }, {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            }>>;
+            triggerSource: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            filePath: string;
+            exportName: string;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            } | undefined;
+            machine?: {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+        }, {
+            id: string;
+            filePath: string;
+            exportName: string;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            } | undefined;
+            machine?: {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        packageVersion: string;
+        contentHash: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            } | undefined;
+            machine?: {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+        }[];
+        cliPackageVersion?: string | undefined;
+    }, {
+        packageVersion: string;
+        contentHash: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            } | undefined;
+            machine?: {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+        }[];
+        cliPackageVersion?: string | undefined;
+    }>;
+    supportsLazyAttempts: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    localOnly: boolean;
+    metadata: {
+        packageVersion: string;
+        contentHash: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            } | undefined;
+            machine?: {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+        }[];
+        cliPackageVersion?: string | undefined;
+    };
+    supportsLazyAttempts?: boolean | undefined;
+}, {
+    localOnly: boolean;
+    metadata: {
+        packageVersion: string;
+        contentHash: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                factor?: number | undefined;
+                minTimeoutInMs?: number | undefined;
+                maxTimeoutInMs?: number | undefined;
+                randomize?: boolean | undefined;
+            } | undefined;
+            machine?: {
+                cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+        }[];
+        cliPackageVersion?: string | undefined;
+    };
+    supportsLazyAttempts?: boolean | undefined;
+}>;
+type CreateBackgroundWorkerRequestBody = z.infer<typeof CreateBackgroundWorkerRequestBody>;
+declare const CreateBackgroundWorkerResponse: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    contentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: string;
+    contentHash: string;
+}, {
+    id: string;
+    version: string;
+    contentHash: string;
+}>;
+type CreateBackgroundWorkerResponse = z.infer<typeof CreateBackgroundWorkerResponse>;
+declare const TriggerTaskRequestBody: z.ZodObject<{
+    payload: z.ZodAny;
+    context: z.ZodAny;
+    options: z.ZodOptional<z.ZodObject<{
+        dependentAttempt: z.ZodOptional<z.ZodString>;
+        dependentBatch: z.ZodOptional<z.ZodString>;
+        lockToVersion: z.ZodOptional<z.ZodString>;
+        queue: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            concurrencyLimit: z.ZodOptional<z.ZodNumber>;
+            rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"fixed-window">;
+                limit: z.ZodNumber;
+                window: z.ZodUnion<[z.ZodObject<{
+                    seconds: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    seconds: number;
+                }, {
+                    seconds: number;
+                }>, z.ZodObject<{
+                    minutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    minutes: number;
+                }, {
+                    minutes: number;
+                }>, z.ZodObject<{
+                    hours: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    hours: number;
+                }, {
+                    hours: number;
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }, {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"sliding-window">;
+                limit: z.ZodNumber;
+                window: z.ZodUnion<[z.ZodObject<{
+                    seconds: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    seconds: number;
+                }, {
+                    seconds: number;
+                }>, z.ZodObject<{
+                    minutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    minutes: number;
+                }, {
+                    minutes: number;
+                }>, z.ZodObject<{
+                    hours: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    hours: number;
+                }, {
+                    hours: number;
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }, {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }>]>>;
+        }, "strip", z.ZodTypeAny, {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        }, {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        }>>;
+        concurrencyKey: z.ZodOptional<z.ZodString>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+        test: z.ZodOptional<z.ZodBoolean>;
+        payloadType: z.ZodOptional<z.ZodString>;
+        delay: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+        ttl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, "strip", z.ZodTypeAny, {
+        dependentAttempt?: string | undefined;
+        dependentBatch?: string | undefined;
+        lockToVersion?: string | undefined;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        concurrencyKey?: string | undefined;
+        idempotencyKey?: string | undefined;
+        test?: boolean | undefined;
+        payloadType?: string | undefined;
+        delay?: string | Date | undefined;
+        ttl?: string | number | undefined;
+    }, {
+        dependentAttempt?: string | undefined;
+        dependentBatch?: string | undefined;
+        lockToVersion?: string | undefined;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        concurrencyKey?: string | undefined;
+        idempotencyKey?: string | undefined;
+        test?: boolean | undefined;
+        payloadType?: string | undefined;
+        delay?: string | Date | undefined;
+        ttl?: string | number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    payload?: any;
+    context?: any;
+    options?: {
+        dependentAttempt?: string | undefined;
+        dependentBatch?: string | undefined;
+        lockToVersion?: string | undefined;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        concurrencyKey?: string | undefined;
+        idempotencyKey?: string | undefined;
+        test?: boolean | undefined;
+        payloadType?: string | undefined;
+        delay?: string | Date | undefined;
+        ttl?: string | number | undefined;
+    } | undefined;
+}, {
+    payload?: any;
+    context?: any;
+    options?: {
+        dependentAttempt?: string | undefined;
+        dependentBatch?: string | undefined;
+        lockToVersion?: string | undefined;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        concurrencyKey?: string | undefined;
+        idempotencyKey?: string | undefined;
+        test?: boolean | undefined;
+        payloadType?: string | undefined;
+        delay?: string | Date | undefined;
+        ttl?: string | number | undefined;
+    } | undefined;
+}>;
+type TriggerTaskRequestBody = z.infer<typeof TriggerTaskRequestBody>;
+declare const TriggerTaskResponse: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+type TriggerTaskResponse = z.infer<typeof TriggerTaskResponse>;
+declare const BatchTriggerTaskRequestBody: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        payload: z.ZodAny;
+        context: z.ZodAny;
+        options: z.ZodOptional<z.ZodObject<{
+            dependentAttempt: z.ZodOptional<z.ZodString>;
+            dependentBatch: z.ZodOptional<z.ZodString>;
+            lockToVersion: z.ZodOptional<z.ZodString>;
+            queue: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                concurrencyLimit: z.ZodOptional<z.ZodNumber>;
+                rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                    type: z.ZodLiteral<"fixed-window">;
+                    limit: z.ZodNumber;
+                    window: z.ZodUnion<[z.ZodObject<{
+                        seconds: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        seconds: number;
+                    }, {
+                        seconds: number;
+                    }>, z.ZodObject<{
+                        minutes: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        minutes: number;
+                    }, {
+                        minutes: number;
+                    }>, z.ZodObject<{
+                        hours: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        hours: number;
+                    }, {
+                        hours: number;
+                    }>]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }, {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"sliding-window">;
+                    limit: z.ZodNumber;
+                    window: z.ZodUnion<[z.ZodObject<{
+                        seconds: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        seconds: number;
+                    }, {
+                        seconds: number;
+                    }>, z.ZodObject<{
+                        minutes: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        minutes: number;
+                    }, {
+                        minutes: number;
+                    }>, z.ZodObject<{
+                        hours: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        hours: number;
+                    }, {
+                        hours: number;
+                    }>]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }, {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                }>]>>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            }, {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            }>>;
+            concurrencyKey: z.ZodOptional<z.ZodString>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+            test: z.ZodOptional<z.ZodBoolean>;
+            payloadType: z.ZodOptional<z.ZodString>;
+            delay: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+            ttl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        }, "strip", z.ZodTypeAny, {
+            dependentAttempt?: string | undefined;
+            dependentBatch?: string | undefined;
+            lockToVersion?: string | undefined;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            concurrencyKey?: string | undefined;
+            idempotencyKey?: string | undefined;
+            test?: boolean | undefined;
+            payloadType?: string | undefined;
+            delay?: string | Date | undefined;
+            ttl?: string | number | undefined;
+        }, {
+            dependentAttempt?: string | undefined;
+            dependentBatch?: string | undefined;
+            lockToVersion?: string | undefined;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            concurrencyKey?: string | undefined;
+            idempotencyKey?: string | undefined;
+            test?: boolean | undefined;
+            payloadType?: string | undefined;
+            delay?: string | Date | undefined;
+            ttl?: string | number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        payload?: any;
+        context?: any;
+        options?: {
+            dependentAttempt?: string | undefined;
+            dependentBatch?: string | undefined;
+            lockToVersion?: string | undefined;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            concurrencyKey?: string | undefined;
+            idempotencyKey?: string | undefined;
+            test?: boolean | undefined;
+            payloadType?: string | undefined;
+            delay?: string | Date | undefined;
+            ttl?: string | number | undefined;
+        } | undefined;
+    }, {
+        payload?: any;
+        context?: any;
+        options?: {
+            dependentAttempt?: string | undefined;
+            dependentBatch?: string | undefined;
+            lockToVersion?: string | undefined;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            concurrencyKey?: string | undefined;
+            idempotencyKey?: string | undefined;
+            test?: boolean | undefined;
+            payloadType?: string | undefined;
+            delay?: string | Date | undefined;
+            ttl?: string | number | undefined;
+        } | undefined;
+    }>, "many">;
+    dependentAttempt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        payload?: any;
+        context?: any;
+        options?: {
+            dependentAttempt?: string | undefined;
+            dependentBatch?: string | undefined;
+            lockToVersion?: string | undefined;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            concurrencyKey?: string | undefined;
+            idempotencyKey?: string | undefined;
+            test?: boolean | undefined;
+            payloadType?: string | undefined;
+            delay?: string | Date | undefined;
+            ttl?: string | number | undefined;
+        } | undefined;
+    }[];
+    dependentAttempt?: string | undefined;
+}, {
+    items: {
+        payload?: any;
+        context?: any;
+        options?: {
+            dependentAttempt?: string | undefined;
+            dependentBatch?: string | undefined;
+            lockToVersion?: string | undefined;
+            queue?: {
+                name?: string | undefined;
+                concurrencyLimit?: number | undefined;
+                rateLimit?: {
+                    type: "fixed-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | {
+                    type: "sliding-window";
+                    limit: number;
+                    window: ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    }) & ({
+                        seconds: number;
+                    } | {
+                        minutes: number;
+                    } | {
+                        hours: number;
+                    } | undefined);
+                } | undefined;
+            } | undefined;
+            concurrencyKey?: string | undefined;
+            idempotencyKey?: string | undefined;
+            test?: boolean | undefined;
+            payloadType?: string | undefined;
+            delay?: string | Date | undefined;
+            ttl?: string | number | undefined;
+        } | undefined;
+    }[];
+    dependentAttempt?: string | undefined;
+}>;
+type BatchTriggerTaskRequestBody = z.infer<typeof BatchTriggerTaskRequestBody>;
+declare const BatchTriggerTaskResponse: z.ZodObject<{
+    batchId: z.ZodString;
+    runs: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    batchId: string;
+    runs: string[];
+}, {
+    batchId: string;
+    runs: string[];
+}>;
+type BatchTriggerTaskResponse = z.infer<typeof BatchTriggerTaskResponse>;
+declare const GetBatchResponseBody: z.ZodObject<{
+    id: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        taskRunId: z.ZodString;
+        status: z.ZodEnum<["PENDING", "CANCELED", "COMPLETED", "FAILED"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }, {
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    items: {
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }[];
+}, {
+    id: string;
+    items: {
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }[];
+}>;
+type GetBatchResponseBody = z.infer<typeof GetBatchResponseBody>;
+declare const RescheduleRunRequestBody: z.ZodObject<{
+    delay: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+}, "strip", z.ZodTypeAny, {
+    delay: (string | Date) & (string | Date | undefined);
+}, {
+    delay: (string | Date) & (string | Date | undefined);
+}>;
+type RescheduleRunRequestBody = z.infer<typeof RescheduleRunRequestBody>;
+declare const GetEnvironmentVariablesResponseBody: z.ZodObject<{
+    variables: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    variables: Record<string, string>;
+}, {
+    variables: Record<string, string>;
+}>;
+type GetEnvironmentVariablesResponseBody = z.infer<typeof GetEnvironmentVariablesResponseBody>;
+declare const StartDeploymentIndexingRequestBody: z.ZodObject<{
+    imageReference: z.ZodString;
+    selfHosted: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    imageReference: string;
+    selfHosted?: boolean | undefined;
+}, {
+    imageReference: string;
+    selfHosted?: boolean | undefined;
+}>;
+type StartDeploymentIndexingRequestBody = z.infer<typeof StartDeploymentIndexingRequestBody>;
+declare const StartDeploymentIndexingResponseBody: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    contentHash: string;
+}, {
+    id: string;
+    contentHash: string;
+}>;
+type StartDeploymentIndexingResponseBody = z.infer<typeof StartDeploymentIndexingResponseBody>;
+declare const ExternalBuildData: z.ZodObject<{
+    buildId: z.ZodString;
+    buildToken: z.ZodString;
+    projectId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    buildId: string;
+    buildToken: string;
+    projectId: string;
+}, {
+    buildId: string;
+    buildToken: string;
+    projectId: string;
+}>;
+type ExternalBuildData = z.infer<typeof ExternalBuildData>;
+declare const InitializeDeploymentResponseBody: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+    shortCode: z.ZodString;
+    version: z.ZodString;
+    imageTag: z.ZodString;
+    externalBuildData: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        buildId: z.ZodString;
+        buildToken: z.ZodString;
+        projectId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        buildId: string;
+        buildToken: string;
+        projectId: string;
+    }, {
+        buildId: string;
+        buildToken: string;
+        projectId: string;
+    }>>>;
+    registryHost: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: string;
+    contentHash: string;
+    imageTag: string;
+    shortCode: string;
+    externalBuildData?: {
+        buildId: string;
+        buildToken: string;
+        projectId: string;
+    } | null | undefined;
+    registryHost?: string | undefined;
+}, {
+    id: string;
+    version: string;
+    contentHash: string;
+    imageTag: string;
+    shortCode: string;
+    externalBuildData?: {
+        buildId: string;
+        buildToken: string;
+        projectId: string;
+    } | null | undefined;
+    registryHost?: string | undefined;
+}>;
+type InitializeDeploymentResponseBody = z.infer<typeof InitializeDeploymentResponseBody>;
+declare const InitializeDeploymentRequestBody: z.ZodObject<{
+    contentHash: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    contentHash: string;
+    userId?: string | undefined;
+}, {
+    contentHash: string;
+    userId?: string | undefined;
+}>;
+type InitializeDeploymentRequestBody = z.infer<typeof InitializeDeploymentRequestBody>;
+declare const DeploymentErrorData: z.ZodObject<{
+    name: z.ZodString;
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    name: string;
+    stack?: string | undefined;
+    stderr?: string | undefined;
+}, {
+    message: string;
+    name: string;
+    stack?: string | undefined;
+    stderr?: string | undefined;
+}>;
+declare const GetDeploymentResponseBody: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<["PENDING", "BUILDING", "DEPLOYING", "DEPLOYED", "FAILED", "CANCELED", "TIMED_OUT"]>;
+    contentHash: z.ZodString;
+    shortCode: z.ZodString;
+    version: z.ZodString;
+    imageReference: z.ZodOptional<z.ZodString>;
+    errorData: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    }, {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    }>>>;
+    worker: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            slug: z.ZodString;
+            filePath: z.ZodString;
+            exportName: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            filePath: string;
+            exportName: string;
+            slug: string;
+        }, {
+            id: string;
+            filePath: string;
+            exportName: string;
+            slug: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            slug: string;
+        }[];
+    }, {
+        id: string;
+        version: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            slug: string;
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: "PENDING" | "CANCELED" | "FAILED" | "BUILDING" | "DEPLOYING" | "DEPLOYED" | "TIMED_OUT";
+    id: string;
+    version: string;
+    contentHash: string;
+    shortCode: string;
+    imageReference?: string | undefined;
+    errorData?: {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    } | null | undefined;
+    worker?: {
+        id: string;
+        version: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            slug: string;
+        }[];
+    } | undefined;
+}, {
+    status: "PENDING" | "CANCELED" | "FAILED" | "BUILDING" | "DEPLOYING" | "DEPLOYED" | "TIMED_OUT";
+    id: string;
+    version: string;
+    contentHash: string;
+    shortCode: string;
+    imageReference?: string | undefined;
+    errorData?: {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    } | null | undefined;
+    worker?: {
+        id: string;
+        version: string;
+        tasks: {
+            id: string;
+            filePath: string;
+            exportName: string;
+            slug: string;
+        }[];
+    } | undefined;
+}>;
+type GetDeploymentResponseBody = z.infer<typeof GetDeploymentResponseBody>;
+declare const CreateUploadPayloadUrlResponseBody: z.ZodObject<{
+    presignedUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    presignedUrl: string;
+}, {
+    presignedUrl: string;
+}>;
+type CreateUploadPayloadUrlResponseBody = z.infer<typeof CreateUploadPayloadUrlResponseBody>;
+declare const ReplayRunResponse: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+type ReplayRunResponse = z.infer<typeof ReplayRunResponse>;
+declare const CanceledRunResponse: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+type CanceledRunResponse = z.infer<typeof CanceledRunResponse>;
+declare const ScheduledTaskPayload: z.ZodObject<{
+    /** The schedule id associated with this run (you can have many schedules for the same task).
+      You can use this to remove the schedule, update it, etc */
+    scheduleId: z.ZodString;
+    /** When the task was scheduled to run.
+     * Note this will be slightly different from `new Date()` because it takes a few ms to run the task.
+     *
+     * This date is UTC. To output it as a string with a timezone you would do this:
+     * ```ts
+     * const formatted = payload.timestamp.toLocaleString("en-US", {
+          timeZone: payload.timezone,
+      });
+      ```  */
+    timestamp: z.ZodDate;
+    /** When the task was last run (it has been).
+      This can be undefined if it's never been run. This date is UTC. */
+    lastTimestamp: z.ZodOptional<z.ZodDate>;
+    /** You can optionally provide an external id when creating the schedule.
+      Usually you would use a userId or some other unique identifier.
+      This defaults to undefined if you didn't provide one. */
+    externalId: z.ZodOptional<z.ZodString>;
+    /** The IANA timezone the schedule is set to. The default is UTC.
+     * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+     */
+    timezone: z.ZodString;
+    /** The next 5 dates this task is scheduled to run */
+    upcoming: z.ZodArray<z.ZodDate, "many">;
+}, "strip", z.ZodTypeAny, {
+    timestamp: Date;
+    scheduleId: string;
+    timezone: string;
+    upcoming: Date[];
+    lastTimestamp?: Date | undefined;
+    externalId?: string | undefined;
+}, {
+    timestamp: Date;
+    scheduleId: string;
+    timezone: string;
+    upcoming: Date[];
+    lastTimestamp?: Date | undefined;
+    externalId?: string | undefined;
+}>;
+type ScheduledTaskPayload = z.infer<typeof ScheduledTaskPayload>;
+declare const CreateScheduleOptions: z.ZodObject<{
+    /** The id of the task you want to attach to. */
+    task: z.ZodString;
+    /**  The schedule in CRON format.
+     *
+     * ```txt
+  *    *    *    *    *    *
+  ┬    ┬    ┬    ┬    ┬
+  │    │    │    │    |
+  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
+  │    │    │    └───── month (1 - 12)
+  │    │    └────────── day of month (1 - 31, L)
+  │    └─────────────── hour (0 - 23)
+  └──────────────────── minute (0 - 59)
+     * ```
+  
+  "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.
+  
+     */
+    cron: z.ZodString;
+    /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+     *
+     * This is required to prevent you from creating duplicate schedules. */
+    deduplicationKey: z.ZodString;
+    /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
+     *
+     * This allows you to have per-user CRON tasks.
+     */
+    externalId: z.ZodOptional<z.ZodString>;
+    /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
+     * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
+     *
+     * 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.
+     *
+     * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+     *
+     * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
+     *
+     */
+    timezone: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    cron: string;
+    deduplicationKey: string;
+    externalId?: string | undefined;
+    timezone?: string | undefined;
+}, {
+    task: string;
+    cron: string;
+    deduplicationKey: string;
+    externalId?: string | undefined;
+    timezone?: string | undefined;
+}>;
+type CreateScheduleOptions = z.infer<typeof CreateScheduleOptions>;
+declare const UpdateScheduleOptions: z.ZodObject<Omit<{
+    /** The id of the task you want to attach to. */
+    task: z.ZodString;
+    /**  The schedule in CRON format.
+     *
+     * ```txt
+  *    *    *    *    *    *
+  ┬    ┬    ┬    ┬    ┬
+  │    │    │    │    |
+  │    │    │    │    └ day of week (0 - 7, 1L - 7L) (0 or 7 is Sun)
+  │    │    │    └───── month (1 - 12)
+  │    │    └────────── day of month (1 - 31, L)
+  │    └─────────────── hour (0 - 23)
+  └──────────────────── minute (0 - 59)
+     * ```
+  
+  "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.
+  
+     */
+    cron: z.ZodString;
+    /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+     *
+     * This is required to prevent you from creating duplicate schedules. */
+    deduplicationKey: z.ZodString;
+    /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
+     *
+     * This allows you to have per-user CRON tasks.
+     */
+    externalId: z.ZodOptional<z.ZodString>;
+    /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
+     * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
+     *
+     * 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.
+     *
+     * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+     *
+     * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
+     *
+     */
+    timezone: z.ZodOptional<z.ZodString>;
+}, "deduplicationKey">, "strip", z.ZodTypeAny, {
+    task: string;
+    cron: string;
+    externalId?: string | undefined;
+    timezone?: string | undefined;
+}, {
+    task: string;
+    cron: string;
+    externalId?: string | undefined;
+    timezone?: string | undefined;
+}>;
+type UpdateScheduleOptions = z.infer<typeof UpdateScheduleOptions>;
+declare const ScheduleGenerator: z.ZodObject<{
+    type: z.ZodLiteral<"CRON">;
+    expression: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "CRON";
+    expression: string;
+    description: string;
+}, {
+    type: "CRON";
+    expression: string;
+    description: string;
+}>;
+type ScheduleGenerator = z.infer<typeof ScheduleGenerator>;
+declare const ScheduleObject: z.ZodObject<{
+    id: z.ZodString;
+    task: z.ZodString;
+    active: z.ZodBoolean;
+    deduplicationKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generator: z.ZodObject<{
+        type: z.ZodLiteral<"CRON">;
+        expression: z.ZodString;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "CRON";
+        expression: string;
+        description: string;
+    }, {
+        type: "CRON";
+        expression: string;
+        description: string;
+    }>;
+    timezone: z.ZodString;
+    nextRun: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    environments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        userName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+        userName?: string | null | undefined;
+    }, {
+        type: string;
+        id: string;
+        userName?: string | null | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    task: string;
+    timezone: string;
+    active: boolean;
+    generator: {
+        type: "CRON";
+        expression: string;
+        description: string;
+    };
+    environments: {
+        type: string;
+        id: string;
+        userName?: string | null | undefined;
+    }[];
+    deduplicationKey?: string | null | undefined;
+    externalId?: string | null | undefined;
+    nextRun?: Date | null | undefined;
+}, {
+    id: string;
+    task: string;
+    timezone: string;
+    active: boolean;
+    generator: {
+        type: "CRON";
+        expression: string;
+        description: string;
+    };
+    environments: {
+        type: string;
+        id: string;
+        userName?: string | null | undefined;
+    }[];
+    deduplicationKey?: string | null | undefined;
+    externalId?: string | null | undefined;
+    nextRun?: Date | null | undefined;
+}>;
+type ScheduleObject = z.infer<typeof ScheduleObject>;
+declare const DeletedScheduleObject: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+type DeletedScheduleObject = z.infer<typeof DeletedScheduleObject>;
+declare const ListSchedulesResult: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        task: z.ZodString;
+        active: z.ZodBoolean;
+        deduplicationKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        generator: z.ZodObject<{
+            type: z.ZodLiteral<"CRON">;
+            expression: z.ZodString;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "CRON";
+            expression: string;
+            description: string;
+        }, {
+            type: "CRON";
+            expression: string;
+            description: string;
+        }>;
+        timezone: z.ZodString;
+        nextRun: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        environments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            userName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            id: string;
+            userName?: string | null | undefined;
+        }, {
+            type: string;
+            id: string;
+            userName?: string | null | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        task: string;
+        timezone: string;
+        active: boolean;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        environments: {
+            type: string;
+            id: string;
+            userName?: string | null | undefined;
+        }[];
+        deduplicationKey?: string | null | undefined;
+        externalId?: string | null | undefined;
+        nextRun?: Date | null | undefined;
+    }, {
+        id: string;
+        task: string;
+        timezone: string;
+        active: boolean;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        environments: {
+            type: string;
+            id: string;
+            userName?: string | null | undefined;
+        }[];
+        deduplicationKey?: string | null | undefined;
+        externalId?: string | null | undefined;
+        nextRun?: Date | null | undefined;
+    }>, "many">;
+    pagination: z.ZodObject<{
+        currentPage: z.ZodNumber;
+        totalPages: z.ZodNumber;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        currentPage: number;
+        totalPages: number;
+        count: number;
+    }, {
+        currentPage: number;
+        totalPages: number;
+        count: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        id: string;
+        task: string;
+        timezone: string;
+        active: boolean;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        environments: {
+            type: string;
+            id: string;
+            userName?: string | null | undefined;
+        }[];
+        deduplicationKey?: string | null | undefined;
+        externalId?: string | null | undefined;
+        nextRun?: Date | null | undefined;
+    }[];
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        count: number;
+    };
+}, {
+    data: {
+        id: string;
+        task: string;
+        timezone: string;
+        active: boolean;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        environments: {
+            type: string;
+            id: string;
+            userName?: string | null | undefined;
+        }[];
+        deduplicationKey?: string | null | undefined;
+        externalId?: string | null | undefined;
+        nextRun?: Date | null | undefined;
+    }[];
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        count: number;
+    };
+}>;
+type ListSchedulesResult = z.infer<typeof ListSchedulesResult>;
+declare const ListScheduleOptions: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+}>;
+type ListScheduleOptions = z.infer<typeof ListScheduleOptions>;
+declare const TimezonesResult: z.ZodObject<{
+    timezones: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    timezones: string[];
+}, {
+    timezones: string[];
+}>;
+type TimezonesResult = z.infer<typeof TimezonesResult>;
+declare const RunStatus: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE", "DELAYED", "EXPIRED"]>;
+type RunStatus = z.infer<typeof RunStatus>;
+declare const AttemptStatus: z.ZodEnum<["PENDING", "EXECUTING", "PAUSED", "COMPLETED", "FAILED", "CANCELED"]>;
+type AttemptStatus = z.infer<typeof AttemptStatus>;
+declare const RunEnvironmentDetails: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    user: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    user?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    user?: string | undefined;
+}>;
+type RunEnvironmentDetails = z.infer<typeof RunEnvironmentDetails>;
+declare const RunScheduleDetails: z.ZodObject<{
+    id: z.ZodString;
+    externalId: z.ZodOptional<z.ZodString>;
+    deduplicationKey: z.ZodOptional<z.ZodString>;
+    generator: z.ZodObject<{
+        type: z.ZodLiteral<"CRON">;
+        expression: z.ZodString;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "CRON";
+        expression: string;
+        description: string;
+    }, {
+        type: "CRON";
+        expression: string;
+        description: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    generator: {
+        type: "CRON";
+        expression: string;
+        description: string;
+    };
+    externalId?: string | undefined;
+    deduplicationKey?: string | undefined;
+}, {
+    id: string;
+    generator: {
+        type: "CRON";
+        expression: string;
+        description: string;
+    };
+    externalId?: string | undefined;
+    deduplicationKey?: string | undefined;
+}>;
+type RunScheduleDetails = z.infer<typeof RunScheduleDetails>;
+declare const RetrieveRunResponse: z.ZodObject<{
+    payload: z.ZodOptional<z.ZodAny>;
+    payloadPresignedUrl: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodAny>;
+    outputPresignedUrl: z.ZodOptional<z.ZodString>;
+    schedule: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        externalId: z.ZodOptional<z.ZodString>;
+        deduplicationKey: z.ZodOptional<z.ZodString>;
+        generator: z.ZodObject<{
+            type: z.ZodLiteral<"CRON">;
+            expression: z.ZodString;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "CRON";
+            expression: string;
+            description: string;
+        }, {
+            type: "CRON";
+            expression: string;
+            description: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    }, {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    }>>;
+    attempts: z.ZodArray<z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<["PENDING", "EXECUTING", "PAUSED", "COMPLETED", "FAILED", "CANCELED"]>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        startedAt: z.ZodOptional<z.ZodDate>;
+        completedAt: z.ZodOptional<z.ZodDate>;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            stackTrace: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        }, {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    }, {
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    }>>, "many">;
+    id: z.ZodString;
+    status: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE", "DELAYED", "EXPIRED"]>;
+    taskIdentifier: z.ZodString;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    isQueued: z.ZodBoolean;
+    isExecuting: z.ZodBoolean;
+    isCompleted: z.ZodBoolean;
+    isSuccess: z.ZodBoolean;
+    isFailed: z.ZodBoolean;
+    isCancelled: z.ZodBoolean;
+    isTest: z.ZodBoolean;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    delayedUntil: z.ZodOptional<z.ZodDate>;
+    ttl: z.ZodOptional<z.ZodString>;
+    expiredAt: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    attempts: ({
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    payload?: any;
+    payloadPresignedUrl?: string | undefined;
+    output?: any;
+    outputPresignedUrl?: string | undefined;
+    schedule?: {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    } | undefined;
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+    delayedUntil?: Date | undefined;
+    ttl?: string | undefined;
+    expiredAt?: Date | undefined;
+}, {
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    attempts: ({
+        status: "PENDING" | "CANCELED" | "COMPLETED" | "FAILED" | "EXECUTING" | "PAUSED";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    payload?: any;
+    payloadPresignedUrl?: string | undefined;
+    output?: any;
+    outputPresignedUrl?: string | undefined;
+    schedule?: {
+        id: string;
+        generator: {
+            type: "CRON";
+            expression: string;
+            description: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    } | undefined;
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+    delayedUntil?: Date | undefined;
+    ttl?: string | undefined;
+    expiredAt?: Date | undefined;
+}>;
+type RetrieveRunResponse = z.infer<typeof RetrieveRunResponse>;
+declare const ListRunResponseItem: z.ZodObject<{
+    env: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        user: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        user?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        user?: string | undefined;
+    }>;
+    id: z.ZodString;
+    status: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE", "DELAYED", "EXPIRED"]>;
+    taskIdentifier: z.ZodString;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    isQueued: z.ZodBoolean;
+    isExecuting: z.ZodBoolean;
+    isCompleted: z.ZodBoolean;
+    isSuccess: z.ZodBoolean;
+    isFailed: z.ZodBoolean;
+    isCancelled: z.ZodBoolean;
+    isTest: z.ZodBoolean;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    finishedAt: z.ZodOptional<z.ZodDate>;
+    delayedUntil: z.ZodOptional<z.ZodDate>;
+    ttl: z.ZodOptional<z.ZodString>;
+    expiredAt: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    env: {
+        id: string;
+        name: string;
+        user?: string | undefined;
+    };
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+    delayedUntil?: Date | undefined;
+    ttl?: string | undefined;
+    expiredAt?: Date | undefined;
+}, {
+    status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    isTest: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    env: {
+        id: string;
+        name: string;
+        user?: string | undefined;
+    };
+    idempotencyKey?: string | undefined;
+    version?: string | undefined;
+    startedAt?: Date | undefined;
+    finishedAt?: Date | undefined;
+    delayedUntil?: Date | undefined;
+    ttl?: string | undefined;
+    expiredAt?: Date | undefined;
+}>;
+type ListRunResponseItem = z.infer<typeof ListRunResponseItem>;
+declare const ListRunResponse: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        env: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            user: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            name: string;
+            user?: string | undefined;
+        }, {
+            id: string;
+            name: string;
+            user?: string | undefined;
+        }>;
+        id: z.ZodString;
+        status: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE", "DELAYED", "EXPIRED"]>;
+        taskIdentifier: z.ZodString;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        isQueued: z.ZodBoolean;
+        isExecuting: z.ZodBoolean;
+        isCompleted: z.ZodBoolean;
+        isSuccess: z.ZodBoolean;
+        isFailed: z.ZodBoolean;
+        isCancelled: z.ZodBoolean;
+        isTest: z.ZodBoolean;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        startedAt: z.ZodOptional<z.ZodDate>;
+        finishedAt: z.ZodOptional<z.ZodDate>;
+        delayedUntil: z.ZodOptional<z.ZodDate>;
+        ttl: z.ZodOptional<z.ZodString>;
+        expiredAt: z.ZodOptional<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        isTest: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            id: string;
+            name: string;
+            user?: string | undefined;
+        };
+        idempotencyKey?: string | undefined;
+        version?: string | undefined;
+        startedAt?: Date | undefined;
+        finishedAt?: Date | undefined;
+        delayedUntil?: Date | undefined;
+        ttl?: string | undefined;
+        expiredAt?: Date | undefined;
+    }, {
+        status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        isTest: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            id: string;
+            name: string;
+            user?: string | undefined;
+        };
+        idempotencyKey?: string | undefined;
+        version?: string | undefined;
+        startedAt?: Date | undefined;
+        finishedAt?: Date | undefined;
+        delayedUntil?: Date | undefined;
+        ttl?: string | undefined;
+        expiredAt?: Date | undefined;
+    }>, "many">;
+    pagination: z.ZodObject<{
+        next: z.ZodOptional<z.ZodString>;
+        previous: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        next?: string | undefined;
+        previous?: string | undefined;
+    }, {
+        next?: string | undefined;
+        previous?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        isTest: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            id: string;
+            name: string;
+            user?: string | undefined;
+        };
+        idempotencyKey?: string | undefined;
+        version?: string | undefined;
+        startedAt?: Date | undefined;
+        finishedAt?: Date | undefined;
+        delayedUntil?: Date | undefined;
+        ttl?: string | undefined;
+        expiredAt?: Date | undefined;
+    }[];
+    pagination: {
+        next?: string | undefined;
+        previous?: string | undefined;
+    };
+}, {
+    data: {
+        status: "CANCELED" | "COMPLETED" | "FAILED" | "WAITING_FOR_DEPLOY" | "QUEUED" | "EXECUTING" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        isTest: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            id: string;
+            name: string;
+            user?: string | undefined;
+        };
+        idempotencyKey?: string | undefined;
+        version?: string | undefined;
+        startedAt?: Date | undefined;
+        finishedAt?: Date | undefined;
+        delayedUntil?: Date | undefined;
+        ttl?: string | undefined;
+        expiredAt?: Date | undefined;
+    }[];
+    pagination: {
+        next?: string | undefined;
+        previous?: string | undefined;
+    };
+}>;
+type ListRunResponse = z.infer<typeof ListRunResponse>;
+declare const CreateEnvironmentVariableRequestBody: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    name: string;
+}, {
+    value: string;
+    name: string;
+}>;
+type CreateEnvironmentVariableRequestBody = z.infer<typeof CreateEnvironmentVariableRequestBody>;
+declare const UpdateEnvironmentVariableRequestBody: z.ZodObject<{
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+}, {
+    value: string;
+}>;
+type UpdateEnvironmentVariableRequestBody = z.infer<typeof UpdateEnvironmentVariableRequestBody>;
+declare const ImportEnvironmentVariablesRequestBody: z.ZodObject<{
+    variables: z.ZodRecord<z.ZodString, z.ZodString>;
+    override: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    variables: Record<string, string>;
+    override?: boolean | undefined;
+}, {
+    variables: Record<string, string>;
+    override?: boolean | undefined;
+}>;
+type ImportEnvironmentVariablesRequestBody = z.infer<typeof ImportEnvironmentVariablesRequestBody>;
+declare const EnvironmentVariableResponseBody: z.ZodObject<{
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+}, {
+    success: boolean;
+}>;
+type EnvironmentVariableResponseBody = z.infer<typeof EnvironmentVariableResponseBody>;
+declare const EnvironmentVariableValue: z.ZodObject<{
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+}, {
+    value: string;
+}>;
+type EnvironmentVariableValue = z.infer<typeof EnvironmentVariableValue>;
+declare const EnvironmentVariable: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    name: string;
+}, {
+    value: string;
+    name: string;
+}>;
+declare const EnvironmentVariables: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    name: string;
+}, {
+    value: string;
+    name: string;
+}>, "many">;
+type EnvironmentVariables = z.infer<typeof EnvironmentVariables>;
+
+declare const TaskResource: z.ZodObject<{
+    id: z.ZodString;
+    filePath: z.ZodString;
+    exportName: z.ZodString;
+    queue: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        concurrencyLimit: z.ZodOptional<z.ZodNumber>;
+        rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"fixed-window">;
+            limit: z.ZodNumber;
+            window: z.ZodUnion<[z.ZodObject<{
+                seconds: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                seconds: number;
+            }, {
+                seconds: number;
+            }>, z.ZodObject<{
+                minutes: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                minutes: number;
+            }, {
+                minutes: number;
+            }>, z.ZodObject<{
+                hours: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                hours: number;
+            }, {
+                hours: number;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "fixed-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        }, {
+            type: "fixed-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"sliding-window">;
+            limit: z.ZodNumber;
+            window: z.ZodUnion<[z.ZodObject<{
+                seconds: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                seconds: number;
+            }, {
+                seconds: number;
+            }>, z.ZodObject<{
+                minutes: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                minutes: number;
+            }, {
+                minutes: number;
+            }>, z.ZodObject<{
+                hours: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                hours: number;
+            }, {
+                hours: number;
+            }>]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "sliding-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        }, {
+            type: "sliding-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        }>]>>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        concurrencyLimit?: number | undefined;
+        rateLimit?: {
+            type: "fixed-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | {
+            type: "sliding-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | undefined;
+    }, {
+        name?: string | undefined;
+        concurrencyLimit?: number | undefined;
+        rateLimit?: {
+            type: "fixed-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | {
+            type: "sliding-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | undefined;
+    }>>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        factor: z.ZodOptional<z.ZodNumber>;
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        randomize: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }>>;
+    machine: z.ZodOptional<z.ZodObject<{
+        cpu: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
+        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>]>>;
+        preset: z.ZodOptional<z.ZodEnum<["micro", "small-1x", "small-2x", "medium-1x", "medium-2x", "large-1x", "large-2x"]>>;
+    }, "strip", z.ZodTypeAny, {
+        cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+        memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+        preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+    }, {
+        cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+        memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+        preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+    }>>;
+    triggerSource: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filePath: string;
+    exportName: string;
+    queue?: {
+        name?: string | undefined;
+        concurrencyLimit?: number | undefined;
+        rateLimit?: {
+            type: "fixed-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | {
+            type: "sliding-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | undefined;
+    } | undefined;
+    retry?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+    machine?: {
+        cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+        memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+        preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+    } | undefined;
+    triggerSource?: string | undefined;
+}, {
+    id: string;
+    filePath: string;
+    exportName: string;
+    queue?: {
+        name?: string | undefined;
+        concurrencyLimit?: number | undefined;
+        rateLimit?: {
+            type: "fixed-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | {
+            type: "sliding-window";
+            limit: number;
+            window: ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            }) & ({
+                seconds: number;
+            } | {
+                minutes: number;
+            } | {
+                hours: number;
+            } | undefined);
+        } | undefined;
+    } | undefined;
+    retry?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+    machine?: {
+        cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+        memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+        preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+    } | undefined;
+    triggerSource?: string | undefined;
+}>;
+type TaskResource = z.infer<typeof TaskResource>;
+declare const BackgroundWorkerMetadata: z.ZodObject<{
+    packageVersion: z.ZodString;
+    contentHash: z.ZodString;
+    cliPackageVersion: z.ZodOptional<z.ZodString>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        filePath: z.ZodString;
+        exportName: z.ZodString;
+        queue: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            concurrencyLimit: z.ZodOptional<z.ZodNumber>;
+            rateLimit: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"fixed-window">;
+                limit: z.ZodNumber;
+                window: z.ZodUnion<[z.ZodObject<{
+                    seconds: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    seconds: number;
+                }, {
+                    seconds: number;
+                }>, z.ZodObject<{
+                    minutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    minutes: number;
+                }, {
+                    minutes: number;
+                }>, z.ZodObject<{
+                    hours: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    hours: number;
+                }, {
+                    hours: number;
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }, {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"sliding-window">;
+                limit: z.ZodNumber;
+                window: z.ZodUnion<[z.ZodObject<{
+                    seconds: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    seconds: number;
+                }, {
+                    seconds: number;
+                }>, z.ZodObject<{
+                    minutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    minutes: number;
+                }, {
+                    minutes: number;
+                }>, z.ZodObject<{
+                    hours: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    hours: number;
+                }, {
+                    hours: number;
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }, {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            }>]>>;
+        }, "strip", z.ZodTypeAny, {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        }, {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        }>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            factor: z.ZodOptional<z.ZodNumber>;
+            minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+            maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+            randomize: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts?: number | undefined;
+            factor?: number | undefined;
+            minTimeoutInMs?: number | undefined;
+            maxTimeoutInMs?: number | undefined;
+            randomize?: boolean | undefined;
+        }, {
+            maxAttempts?: number | undefined;
+            factor?: number | undefined;
+            minTimeoutInMs?: number | undefined;
+            maxTimeoutInMs?: number | undefined;
+            randomize?: boolean | undefined;
+        }>>;
+        machine: z.ZodOptional<z.ZodObject<{
+            cpu: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
+            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>]>>;
+            preset: z.ZodOptional<z.ZodEnum<["micro", "small-1x", "small-2x", "medium-1x", "medium-2x", "large-1x", "large-2x"]>>;
+        }, "strip", z.ZodTypeAny, {
+            cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+            memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+            preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+        }, {
+            cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+            memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+            preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+        }>>;
+        triggerSource: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        filePath: string;
+        exportName: string;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            factor?: number | undefined;
+            minTimeoutInMs?: number | undefined;
+            maxTimeoutInMs?: number | undefined;
+            randomize?: boolean | undefined;
+        } | undefined;
+        machine?: {
+            cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+            memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+            preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+        } | undefined;
+        triggerSource?: string | undefined;
+    }, {
+        id: string;
+        filePath: string;
+        exportName: string;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            factor?: number | undefined;
+            minTimeoutInMs?: number | undefined;
+            maxTimeoutInMs?: number | undefined;
+            randomize?: boolean | undefined;
+        } | undefined;
+        machine?: {
+            cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+            memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+            preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+        } | undefined;
+        triggerSource?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    packageVersion: string;
+    contentHash: string;
+    tasks: {
+        id: string;
+        filePath: string;
+        exportName: string;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            factor?: number | undefined;
+            minTimeoutInMs?: number | undefined;
+            maxTimeoutInMs?: number | undefined;
+            randomize?: boolean | undefined;
+        } | undefined;
+        machine?: {
+            cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+            memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+            preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+        } | undefined;
+        triggerSource?: string | undefined;
+    }[];
+    cliPackageVersion?: string | undefined;
+}, {
+    packageVersion: string;
+    contentHash: string;
+    tasks: {
+        id: string;
+        filePath: string;
+        exportName: string;
+        queue?: {
+            name?: string | undefined;
+            concurrencyLimit?: number | undefined;
+            rateLimit?: {
+                type: "fixed-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | {
+                type: "sliding-window";
+                limit: number;
+                window: ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                }) & ({
+                    seconds: number;
+                } | {
+                    minutes: number;
+                } | {
+                    hours: number;
+                } | undefined);
+            } | undefined;
+        } | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            factor?: number | undefined;
+            minTimeoutInMs?: number | undefined;
+            maxTimeoutInMs?: number | undefined;
+            randomize?: boolean | undefined;
+        } | undefined;
+        machine?: {
+            cpu?: 2 | 1 | 4 | 0.25 | 0.5 | undefined;
+            memory?: 2 | 1 | 4 | 0.25 | 0.5 | 8 | undefined;
+            preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+        } | undefined;
+        triggerSource?: string | undefined;
+    }[];
+    cliPackageVersion?: string | undefined;
+}>;
+type BackgroundWorkerMetadata = z.infer<typeof BackgroundWorkerMetadata>;
+declare const ImageDetailsMetadata: z.ZodObject<{
+    contentHash: z.ZodString;
+    imageTag: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    contentHash: string;
+    imageTag: string;
+}, {
+    contentHash: string;
+    imageTag: string;
+}>;
+type ImageDetailsMetadata = z.infer<typeof ImageDetailsMetadata>;
+
+declare const PRIMARY_VARIANT = "primary";
+declare const Variant: z.ZodEnum<["primary"]>;
+type Variant = z.infer<typeof Variant>;
+declare const Accessory: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        variant?: string | undefined;
+        url?: string | undefined;
+    }, {
+        text: string;
+        variant?: string | undefined;
+        url?: string | undefined;
+    }>, "many">;
+    style: z.ZodOptional<z.ZodEnum<["codepath"]>>;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        text: string;
+        variant?: string | undefined;
+        url?: string | undefined;
+    }[];
+    style?: "codepath" | undefined;
+}, {
+    items: {
+        text: string;
+        variant?: string | undefined;
+        url?: string | undefined;
+    }[];
+    style?: "codepath" | undefined;
+}>;
+type Accessory = z.infer<typeof Accessory>;
+declare const TaskEventStyle: z.ZodDefault<z.ZodObject<{
+    icon: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodEnum<["primary"]>>;
+    accessory: z.ZodOptional<z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            text: string;
+            variant?: string | undefined;
+            url?: string | undefined;
+        }, {
+            text: string;
+            variant?: string | undefined;
+            url?: string | undefined;
+        }>, "many">;
+        style: z.ZodOptional<z.ZodEnum<["codepath"]>>;
+    }, "strip", z.ZodTypeAny, {
+        items: {
+            text: string;
+            variant?: string | undefined;
+            url?: string | undefined;
+        }[];
+        style?: "codepath" | undefined;
+    }, {
+        items: {
+            text: string;
+            variant?: string | undefined;
+            url?: string | undefined;
+        }[];
+        style?: "codepath" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    icon?: string | undefined;
+    variant?: "primary" | undefined;
+    accessory?: {
+        items: {
+            text: string;
+            variant?: string | undefined;
+            url?: string | undefined;
+        }[];
+        style?: "codepath" | undefined;
+    } | undefined;
+}, {
+    icon?: string | undefined;
+    variant?: "primary" | undefined;
+    accessory?: {
+        items: {
+            text: string;
+            variant?: string | undefined;
+            url?: string | undefined;
+        }[];
+        style?: "codepath" | undefined;
+    } | undefined;
+}>>;
+type TaskEventStyle = z.infer<typeof TaskEventStyle>;
+
+declare const stringPatternMatchers: readonly [z.ZodObject<{
+    $endsWith: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    $endsWith: string;
+}, {
+    $endsWith: string;
+}>, z.ZodObject<{
+    $startsWith: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    $startsWith: string;
+}, {
+    $startsWith: string;
+}>, z.ZodObject<{
+    $ignoreCaseEquals: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    $ignoreCaseEquals: string;
+}, {
+    $ignoreCaseEquals: string;
+}>];
+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<{
+    $endsWith: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    $endsWith: string;
+}, {
+    $endsWith: string;
+}>, z.ZodObject<{
+    $startsWith: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    $startsWith: string;
+}, {
+    $startsWith: string;
+}>, z.ZodObject<{
+    $ignoreCaseEquals: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    $ignoreCaseEquals: string;
+}, {
+    $ignoreCaseEquals: string;
+}>, z.ZodObject<{
+    $exists: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    $exists: boolean;
+}, {
+    $exists: boolean;
+}>, z.ZodObject<{
+    $isNull: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    $isNull: boolean;
+}, {
+    $isNull: boolean;
+}>, z.ZodObject<{
+    $anythingBut: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, "strip", z.ZodTypeAny, {
+    $anythingBut: string | number | boolean;
+}, {
+    $anythingBut: string | number | boolean;
+}>, z.ZodObject<{
+    $anythingBut: z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>;
+}, "strip", z.ZodTypeAny, {
+    $anythingBut: (string[] | number[] | boolean[]) & (string[] | number[] | boolean[] | undefined);
+}, {
+    $anythingBut: (string[] | number[] | boolean[]) & (string[] | number[] | boolean[] | undefined);
+}>, z.ZodObject<{
+    $gt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    $gt: number;
+}, {
+    $gt: number;
+}>, z.ZodObject<{
+    $lt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    $lt: number;
+}, {
+    $lt: number;
+}>, z.ZodObject<{
+    $gte: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    $gte: number;
+}, {
+    $gte: number;
+}>, z.ZodObject<{
+    $lte: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    $lte: number;
+}, {
+    $lte: number;
+}>, z.ZodObject<{
+    $between: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+}, "strip", z.ZodTypeAny, {
+    $between: [number, number];
+}, {
+    $between: [number, number];
+}>, z.ZodObject<{
+    $includes: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, "strip", z.ZodTypeAny, {
+    $includes: string | number | boolean;
+}, {
+    $includes: string | number | boolean;
+}>, z.ZodObject<{
+    $not: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, "strip", z.ZodTypeAny, {
+    $not: string | number | boolean;
+}, {
+    $not: string | number | boolean;
+}>]>, "many">]>;
+type EventMatcher = z.infer<typeof EventMatcher>;
+/** A filter for matching against data */
+type EventFilter = {
+    [key: string]: EventMatcher | EventFilter;
+};
+declare const EventFilter: z.ZodType<EventFilter>;
+
+declare const FetchRetryHeadersStrategy: z.ZodObject<{
+    /** The `headers` strategy retries the request using info from the response headers. */
+    strategy: z.ZodLiteral<"headers">;
+    /** The header to use to determine the maximum number of times to retry the request. */
+    limitHeader: z.ZodString;
+    /** The header to use to determine the number of remaining retries. */
+    remainingHeader: z.ZodString;
+    /** The header to use to determine the time when the number of remaining retries will be reset. */
+    resetHeader: z.ZodString;
+    /** The event filter to use to determine if the request should be retried. */
+    bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+    /** The format of the `resetHeader` value. */
+    resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "headers";
+    limitHeader: string;
+    remainingHeader: string;
+    resetHeader: string;
+    bodyFilter?: EventFilter | undefined;
+    resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+}, {
+    strategy: "headers";
+    limitHeader: string;
+    remainingHeader: string;
+    resetHeader: string;
+    bodyFilter?: EventFilter | undefined;
+    resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+}>;
+type FetchRetryHeadersStrategy = z.infer<typeof FetchRetryHeadersStrategy>;
+declare const FetchRetryBackoffStrategy: z.ZodObject<{
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+    factor: z.ZodOptional<z.ZodNumber>;
+    minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+    maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+    randomize: z.ZodOptional<z.ZodBoolean>;
+    strategy: z.ZodLiteral<"backoff">;
+    bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "backoff";
+    maxAttempts?: number | undefined;
+    factor?: number | undefined;
+    minTimeoutInMs?: number | undefined;
+    maxTimeoutInMs?: number | undefined;
+    randomize?: boolean | undefined;
+    bodyFilter?: EventFilter | undefined;
+}, {
+    strategy: "backoff";
+    maxAttempts?: number | undefined;
+    factor?: number | undefined;
+    minTimeoutInMs?: number | undefined;
+    maxTimeoutInMs?: number | undefined;
+    randomize?: boolean | undefined;
+    bodyFilter?: EventFilter | undefined;
+}>;
+/** The `backoff` strategy retries the request with an exponential backoff. */
+type FetchRetryBackoffStrategy = z.infer<typeof FetchRetryBackoffStrategy>;
+declare const FetchRetryStrategy: z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
+    /** The `headers` strategy retries the request using info from the response headers. */
+    strategy: z.ZodLiteral<"headers">;
+    /** The header to use to determine the maximum number of times to retry the request. */
+    limitHeader: z.ZodString;
+    /** The header to use to determine the number of remaining retries. */
+    remainingHeader: z.ZodString;
+    /** The header to use to determine the time when the number of remaining retries will be reset. */
+    resetHeader: z.ZodString;
+    /** The event filter to use to determine if the request should be retried. */
+    bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+    /** The format of the `resetHeader` value. */
+    resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "headers";
+    limitHeader: string;
+    remainingHeader: string;
+    resetHeader: string;
+    bodyFilter?: EventFilter | undefined;
+    resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+}, {
+    strategy: "headers";
+    limitHeader: string;
+    remainingHeader: string;
+    resetHeader: string;
+    bodyFilter?: EventFilter | undefined;
+    resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+}>, z.ZodObject<{
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+    factor: z.ZodOptional<z.ZodNumber>;
+    minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+    maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+    randomize: z.ZodOptional<z.ZodBoolean>;
+    strategy: z.ZodLiteral<"backoff">;
+    bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "backoff";
+    maxAttempts?: number | undefined;
+    factor?: number | undefined;
+    minTimeoutInMs?: number | undefined;
+    maxTimeoutInMs?: number | undefined;
+    randomize?: boolean | undefined;
+    bodyFilter?: EventFilter | undefined;
+}, {
+    strategy: "backoff";
+    maxAttempts?: number | undefined;
+    factor?: number | undefined;
+    minTimeoutInMs?: number | undefined;
+    maxTimeoutInMs?: number | undefined;
+    randomize?: boolean | undefined;
+    bodyFilter?: EventFilter | undefined;
+}>]>;
+type FetchRetryStrategy = z.infer<typeof FetchRetryStrategy>;
+declare const FetchRetryByStatusOptions: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
+    /** The `headers` strategy retries the request using info from the response headers. */
+    strategy: z.ZodLiteral<"headers">;
+    /** The header to use to determine the maximum number of times to retry the request. */
+    limitHeader: z.ZodString;
+    /** The header to use to determine the number of remaining retries. */
+    remainingHeader: z.ZodString;
+    /** The header to use to determine the time when the number of remaining retries will be reset. */
+    resetHeader: z.ZodString;
+    /** The event filter to use to determine if the request should be retried. */
+    bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+    /** The format of the `resetHeader` value. */
+    resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "headers";
+    limitHeader: string;
+    remainingHeader: string;
+    resetHeader: string;
+    bodyFilter?: EventFilter | undefined;
+    resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+}, {
+    strategy: "headers";
+    limitHeader: string;
+    remainingHeader: string;
+    resetHeader: string;
+    bodyFilter?: EventFilter | undefined;
+    resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+}>, z.ZodObject<{
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+    factor: z.ZodOptional<z.ZodNumber>;
+    minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+    maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+    randomize: z.ZodOptional<z.ZodBoolean>;
+    strategy: z.ZodLiteral<"backoff">;
+    bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "backoff";
+    maxAttempts?: number | undefined;
+    factor?: number | undefined;
+    minTimeoutInMs?: number | undefined;
+    maxTimeoutInMs?: number | undefined;
+    randomize?: boolean | undefined;
+    bodyFilter?: EventFilter | undefined;
+}, {
+    strategy: "backoff";
+    maxAttempts?: number | undefined;
+    factor?: number | undefined;
+    minTimeoutInMs?: number | undefined;
+    maxTimeoutInMs?: number | undefined;
+    randomize?: boolean | undefined;
+    bodyFilter?: EventFilter | undefined;
+}>]>>;
+/** An object where the key is a status code pattern and the value is a retrying strategy. Supported patterns are:
+  - Specific status codes: 429
+  - Ranges: 500-599
+  - Wildcards: 2xx, 3xx, 4xx, 5xx
+  */
+type FetchRetryByStatusOptions = Prettify<z.infer<typeof FetchRetryByStatusOptions>>;
+declare const FetchTimeoutOptions: z.ZodObject<{
+    /** The maximum time to wait for the request to complete. */
+    durationInMs: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        /** The retrying strategy for specific status codes. */
+        factor: z.ZodOptional<z.ZodNumber>; /**
+         * The retrying strategy for connection errors.
+         */
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        randomize: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    durationInMs?: number | undefined;
+    retry?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+}, {
+    durationInMs?: number | undefined;
+    retry?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+}>;
+type FetchTimeoutOptions = z.infer<typeof FetchTimeoutOptions>;
+declare const FetchRetryOptions: z.ZodObject<{
+    /** The retrying strategy for specific status codes. */
+    byStatus: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
+        /** The `headers` strategy retries the request using info from the response headers. */
+        strategy: z.ZodLiteral<"headers">;
+        /** The header to use to determine the maximum number of times to retry the request. */
+        limitHeader: z.ZodString;
+        /** The header to use to determine the number of remaining retries. */
+        remainingHeader: z.ZodString;
+        /** The header to use to determine the time when the number of remaining retries will be reset. */
+        resetHeader: z.ZodString;
+        /** The event filter to use to determine if the request should be retried. */
+        bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+        /** The format of the `resetHeader` value. */
+        resetFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<["unix_timestamp", "unix_timestamp_in_ms", "iso_8601", "iso_8601_duration_openai_variant"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "headers";
+        limitHeader: string;
+        remainingHeader: string;
+        resetHeader: string;
+        bodyFilter?: EventFilter | undefined;
+        resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+    }, {
+        strategy: "headers";
+        limitHeader: string;
+        remainingHeader: string;
+        resetHeader: string;
+        bodyFilter?: EventFilter | undefined;
+        resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+    }>, z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        factor: z.ZodOptional<z.ZodNumber>;
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        randomize: z.ZodOptional<z.ZodBoolean>;
+        strategy: z.ZodLiteral<"backoff">;
+        bodyFilter: z.ZodOptional<z.ZodType<EventFilter, z.ZodTypeDef, EventFilter>>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "backoff";
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+        bodyFilter?: EventFilter | undefined;
+    }, {
+        strategy: "backoff";
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+        bodyFilter?: EventFilter | undefined;
+    }>]>>>;
+    /** The timeout options for the request. */
+    timeout: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        /** The retrying strategy for specific status codes. */
+        factor: z.ZodOptional<z.ZodNumber>; /**
+         * The retrying strategy for connection errors.
+         */
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        randomize: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }>>;
+    /**
+     * The retrying strategy for connection errors.
+     */
+    connectionError: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        /** The retrying strategy for specific status codes. */
+        factor: z.ZodOptional<z.ZodNumber>; /**
+         * The retrying strategy for connection errors.
+         */
+        minTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        maxTimeoutInMs: z.ZodOptional<z.ZodNumber>;
+        randomize: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    byStatus?: Record<string, {
+        strategy: "headers";
+        limitHeader: string;
+        remainingHeader: string;
+        resetHeader: string;
+        bodyFilter?: EventFilter | undefined;
+        resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+    } | {
+        strategy: "backoff";
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+        bodyFilter?: EventFilter | undefined;
+    }> | undefined;
+    timeout?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+    connectionError?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+}, {
+    byStatus?: Record<string, {
+        strategy: "headers";
+        limitHeader: string;
+        remainingHeader: string;
+        resetHeader: string;
+        bodyFilter?: EventFilter | undefined;
+        resetFormat?: "unix_timestamp" | "unix_timestamp_in_ms" | "iso_8601" | "iso_8601_duration_openai_variant" | undefined;
+    } | {
+        strategy: "backoff";
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+        bodyFilter?: EventFilter | undefined;
+    }> | undefined;
+    timeout?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+    connectionError?: {
+        maxAttempts?: number | undefined;
+        factor?: number | undefined;
+        minTimeoutInMs?: number | undefined;
+        maxTimeoutInMs?: number | undefined;
+        randomize?: boolean | undefined;
+    } | undefined;
+}>;
+type FetchRetryOptions = Prettify<z.infer<typeof FetchRetryOptions>>;
+
+declare const ExceptionEventProperties: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    stacktrace: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: string | undefined;
+    message?: string | undefined;
+    stacktrace?: string | undefined;
+}, {
+    type?: string | undefined;
+    message?: string | undefined;
+    stacktrace?: string | undefined;
+}>;
+type ExceptionEventProperties = z.infer<typeof ExceptionEventProperties>;
+declare const ExceptionSpanEvent: z.ZodObject<{
+    name: z.ZodLiteral<"exception">;
+    time: z.ZodDate;
+    properties: z.ZodObject<{
+        exception: z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            stacktrace: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        }, {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    }, {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "exception";
+    time: Date;
+    properties: {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    };
+}, {
+    name: "exception";
+    time: Date;
+    properties: {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    };
+}>;
+type ExceptionSpanEvent = z.infer<typeof ExceptionSpanEvent>;
+declare const CancellationSpanEvent: z.ZodObject<{
+    name: z.ZodLiteral<"cancellation">;
+    time: z.ZodDate;
+    properties: z.ZodObject<{
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+    }, {
+        reason: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "cancellation";
+    time: Date;
+    properties: {
+        reason: string;
+    };
+}, {
+    name: "cancellation";
+    time: Date;
+    properties: {
+        reason: string;
+    };
+}>;
+type CancellationSpanEvent = z.infer<typeof CancellationSpanEvent>;
+declare const OtherSpanEvent: z.ZodObject<{
+    name: z.ZodString;
+    time: z.ZodDate;
+    properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    time: Date;
+    properties: Record<string, unknown>;
+}, {
+    name: string;
+    time: Date;
+    properties: Record<string, unknown>;
+}>;
+type OtherSpanEvent = z.infer<typeof OtherSpanEvent>;
+declare const SpanEvent: z.ZodUnion<[z.ZodObject<{
+    name: z.ZodLiteral<"exception">;
+    time: z.ZodDate;
+    properties: z.ZodObject<{
+        exception: z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            stacktrace: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        }, {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    }, {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "exception";
+    time: Date;
+    properties: {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    };
+}, {
+    name: "exception";
+    time: Date;
+    properties: {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"cancellation">;
+    time: z.ZodDate;
+    properties: z.ZodObject<{
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+    }, {
+        reason: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "cancellation";
+    time: Date;
+    properties: {
+        reason: string;
+    };
+}, {
+    name: "cancellation";
+    time: Date;
+    properties: {
+        reason: string;
+    };
+}>, z.ZodObject<{
+    name: z.ZodString;
+    time: z.ZodDate;
+    properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    time: Date;
+    properties: Record<string, unknown>;
+}, {
+    name: string;
+    time: Date;
+    properties: Record<string, unknown>;
+}>]>;
+type SpanEvent = z.infer<typeof SpanEvent>;
+declare const SpanEvents: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+    name: z.ZodLiteral<"exception">;
+    time: z.ZodDate;
+    properties: z.ZodObject<{
+        exception: z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            stacktrace: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        }, {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    }, {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "exception";
+    time: Date;
+    properties: {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    };
+}, {
+    name: "exception";
+    time: Date;
+    properties: {
+        exception: {
+            type?: string | undefined;
+            message?: string | undefined;
+            stacktrace?: string | undefined;
+        };
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"cancellation">;
+    time: z.ZodDate;
+    properties: z.ZodObject<{
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+    }, {
+        reason: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "cancellation";
+    time: Date;
+    properties: {
+        reason: string;
+    };
+}, {
+    name: "cancellation";
+    time: Date;
+    properties: {
+        reason: string;
+    };
+}>, z.ZodObject<{
+    name: z.ZodString;
+    time: z.ZodDate;
+    properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    time: Date;
+    properties: Record<string, unknown>;
+}, {
+    name: string;
+    time: Date;
+    properties: Record<string, unknown>;
+}>]>, "many">;
+type SpanEvents = z.infer<typeof SpanEvents>;
+declare function isExceptionSpanEvent(event: SpanEvent): event is ExceptionSpanEvent;
+declare function isCancellationSpanEvent(event: SpanEvent): event is CancellationSpanEvent;
+declare const SpanMessagingEvent: z.ZodObject<{
+    system: z.ZodOptional<z.ZodString>;
+    client_id: z.ZodOptional<z.ZodString>;
+    operation: z.ZodEnum<["publish", "create", "receive", "deliver"]>;
+    message: z.ZodAny;
+    destination: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    operation: "create" | "publish" | "receive" | "deliver";
+    system?: string | undefined;
+    client_id?: string | undefined;
+    message?: any;
+    destination?: string | undefined;
+}, {
+    operation: "create" | "publish" | "receive" | "deliver";
+    system?: string | undefined;
+    client_id?: string | undefined;
+    message?: any;
+    destination?: string | undefined;
+}>;
+type SpanMessagingEvent = z.infer<typeof SpanMessagingEvent>;
+
+export { Accessory, AttemptStatus, BackgroundWorkerMetadata, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, type CreateAuthorizationCodeResponse, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateEnvironmentVariableRequestBody, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, 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, ImageDetailsMetadata, ImportEnvironmentVariablesRequestBody, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, ListRunResponse, ListRunResponseItem, ListScheduleOptions, ListSchedulesResult, OtherSpanEvent, PRIMARY_VARIANT, ReplayRunResponse, RescheduleRunRequestBody, RetrieveRunResponse, RunEnvironmentDetails, RunScheduleDetails, RunStatus, ScheduleGenerator, ScheduleObject, ScheduledTaskPayload, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskResource, TimezonesResult, TriggerTaskRequestBody, TriggerTaskResponse, UpdateEnvironmentVariableRequestBody, UpdateScheduleOptions, Variant, type WhoAmIResponse, WhoAmIResponseSchema, isCancellationSpanEvent, isExceptionSpanEvent, stringPatternMatchers };