@trigger.dev/core 3.0.0-beta.7 → 3.0.0

package/dist/commonjs/v3/schemas/api.d.ts

@@ -0,0 +1,3138 @@
+import { z } from "zod";
+export 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;
+}>;
+export type WhoAmIResponse = z.infer<typeof WhoAmIResponseSchema>;
+export 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;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    }, {
+        id: string;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    slug: string;
+    organization: {
+        id: string;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    };
+    createdAt: Date;
+    externalRef: string;
+}, {
+    name: string;
+    id: string;
+    slug: string;
+    organization: {
+        id: string;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    };
+    createdAt: Date;
+    externalRef: string;
+}>;
+export type GetProjectResponseBody = z.infer<typeof GetProjectResponseBody>;
+export 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;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    }, {
+        id: string;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    slug: string;
+    organization: {
+        id: string;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    };
+    createdAt: Date;
+    externalRef: string;
+}, {
+    name: string;
+    id: string;
+    slug: string;
+    organization: {
+        id: string;
+        title: string;
+        slug: string;
+        createdAt: Date;
+    };
+    createdAt: Date;
+    externalRef: string;
+}>, "many">;
+export type GetProjectsResponseBody = z.infer<typeof GetProjectsResponseBody>;
+export declare const GetProjectEnvResponse: z.ZodObject<{
+    apiKey: z.ZodString;
+    name: z.ZodString;
+    apiUrl: z.ZodString;
+    projectId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    apiKey: string;
+    apiUrl: string;
+    projectId: string;
+}, {
+    name: string;
+    apiKey: string;
+    apiUrl: string;
+    projectId: string;
+}>;
+export type GetProjectEnvResponse = z.infer<typeof GetProjectEnvResponse>;
+export 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?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            }, {
+                cpu?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            }>>;
+            triggerSource: z.ZodOptional<z.ZodString>;
+            schedule: z.ZodOptional<z.ZodObject<{
+                cron: z.ZodString;
+                timezone: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                cron: string;
+                timezone: string;
+            }, {
+                cron: string;
+                timezone: string;
+            }>>;
+        }, "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?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+            schedule?: {
+                cron: string;
+                timezone: 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?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+            schedule?: {
+                cron: string;
+                timezone: string;
+            } | undefined;
+        }>, "many">;
+        sourceFiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            filePath: z.ZodString;
+            contents: z.ZodString;
+            contentHash: z.ZodString;
+            taskIds: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            filePath: string;
+            contentHash: string;
+            contents: string;
+            taskIds: string[];
+        }, {
+            filePath: string;
+            contentHash: string;
+            contents: string;
+            taskIds: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        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?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+            schedule?: {
+                cron: string;
+                timezone: string;
+            } | undefined;
+        }[];
+        contentHash: string;
+        packageVersion: string;
+        cliPackageVersion?: string | undefined;
+        sourceFiles?: {
+            filePath: string;
+            contentHash: string;
+            contents: string;
+            taskIds: string[];
+        }[] | undefined;
+    }, {
+        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?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+            schedule?: {
+                cron: string;
+                timezone: string;
+            } | undefined;
+        }[];
+        contentHash: string;
+        packageVersion: string;
+        cliPackageVersion?: string | undefined;
+        sourceFiles?: {
+            filePath: string;
+            contentHash: string;
+            contents: string;
+            taskIds: string[];
+        }[] | undefined;
+    }>;
+    supportsLazyAttempts: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    metadata: {
+        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?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+            schedule?: {
+                cron: string;
+                timezone: string;
+            } | undefined;
+        }[];
+        contentHash: string;
+        packageVersion: string;
+        cliPackageVersion?: string | undefined;
+        sourceFiles?: {
+            filePath: string;
+            contentHash: string;
+            contents: string;
+            taskIds: string[];
+        }[] | undefined;
+    };
+    localOnly: boolean;
+    supportsLazyAttempts?: boolean | undefined;
+}, {
+    metadata: {
+        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?: 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                memory?: 8 | 1 | 2 | 4 | 0.25 | 0.5 | undefined;
+                preset?: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x" | undefined;
+            } | undefined;
+            triggerSource?: string | undefined;
+            schedule?: {
+                cron: string;
+                timezone: string;
+            } | undefined;
+        }[];
+        contentHash: string;
+        packageVersion: string;
+        cliPackageVersion?: string | undefined;
+        sourceFiles?: {
+            filePath: string;
+            contentHash: string;
+            contents: string;
+            taskIds: string[];
+        }[] | undefined;
+    };
+    localOnly: boolean;
+    supportsLazyAttempts?: boolean | undefined;
+}>;
+export type CreateBackgroundWorkerRequestBody = z.infer<typeof CreateBackgroundWorkerRequestBody>;
+export declare const CreateBackgroundWorkerResponse: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    contentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    id: string;
+    contentHash: string;
+}, {
+    version: string;
+    id: string;
+    contentHash: string;
+}>;
+export type CreateBackgroundWorkerResponse = z.infer<typeof CreateBackgroundWorkerResponse>;
+export declare const RunTags: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+export type RunTags = z.infer<typeof RunTags>;
+export 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]>>;
+        tags: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        maxAttempts: z.ZodOptional<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;
+        tags?: string | string[] | undefined;
+        maxAttempts?: 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;
+        tags?: string | string[] | undefined;
+        maxAttempts?: 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;
+        tags?: string | string[] | undefined;
+        maxAttempts?: 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;
+        tags?: string | string[] | undefined;
+        maxAttempts?: number | undefined;
+    } | undefined;
+}>;
+export type TriggerTaskRequestBody = z.infer<typeof TriggerTaskRequestBody>;
+export declare const TriggerTaskResponse: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type TriggerTaskResponse = z.infer<typeof TriggerTaskResponse>;
+export 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]>>;
+            tags: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            maxAttempts: z.ZodOptional<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;
+            tags?: string | string[] | undefined;
+            maxAttempts?: 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;
+            tags?: string | string[] | undefined;
+            maxAttempts?: 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;
+            tags?: string | string[] | undefined;
+            maxAttempts?: 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;
+            tags?: string | string[] | undefined;
+            maxAttempts?: 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;
+            tags?: string | string[] | undefined;
+            maxAttempts?: 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;
+            tags?: string | string[] | undefined;
+            maxAttempts?: number | undefined;
+        } | undefined;
+    }[];
+    dependentAttempt?: string | undefined;
+}>;
+export type BatchTriggerTaskRequestBody = z.infer<typeof BatchTriggerTaskRequestBody>;
+export declare const BatchTriggerTaskResponse: z.ZodObject<{
+    batchId: z.ZodString;
+    runs: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    runs: string[];
+    batchId: string;
+}, {
+    runs: string[];
+    batchId: string;
+}>;
+export type BatchTriggerTaskResponse = z.infer<typeof BatchTriggerTaskResponse>;
+export 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" | "COMPLETED" | "CANCELED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }, {
+        status: "PENDING" | "COMPLETED" | "CANCELED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    items: {
+        status: "PENDING" | "COMPLETED" | "CANCELED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }[];
+}, {
+    id: string;
+    items: {
+        status: "PENDING" | "COMPLETED" | "CANCELED" | "FAILED";
+        id: string;
+        taskRunId: string;
+    }[];
+}>;
+export type GetBatchResponseBody = z.infer<typeof GetBatchResponseBody>;
+export declare const AddTagsRequestBody: z.ZodObject<{
+    tags: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+}, "strip", z.ZodTypeAny, {
+    tags: (string | string[]) & (string | string[] | undefined);
+}, {
+    tags: (string | string[]) & (string | string[] | undefined);
+}>;
+export type AddTagsRequestBody = z.infer<typeof AddTagsRequestBody>;
+export 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);
+}>;
+export type RescheduleRunRequestBody = z.infer<typeof RescheduleRunRequestBody>;
+export declare const GetEnvironmentVariablesResponseBody: z.ZodObject<{
+    variables: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    variables: Record<string, string>;
+}, {
+    variables: Record<string, string>;
+}>;
+export type GetEnvironmentVariablesResponseBody = z.infer<typeof GetEnvironmentVariablesResponseBody>;
+export 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;
+}>;
+export type StartDeploymentIndexingRequestBody = z.infer<typeof StartDeploymentIndexingRequestBody>;
+export declare const StartDeploymentIndexingResponseBody: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    contentHash: string;
+}, {
+    id: string;
+    contentHash: string;
+}>;
+export type StartDeploymentIndexingResponseBody = z.infer<typeof StartDeploymentIndexingResponseBody>;
+export declare const FinalizeDeploymentRequestBody: z.ZodObject<{
+    imageReference: z.ZodString;
+    selfHosted: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    imageReference: string;
+    selfHosted?: boolean | undefined;
+}, {
+    imageReference: string;
+    selfHosted?: boolean | undefined;
+}>;
+export type FinalizeDeploymentRequestBody = z.infer<typeof FinalizeDeploymentRequestBody>;
+export declare const ExternalBuildData: z.ZodObject<{
+    buildId: z.ZodString;
+    buildToken: z.ZodString;
+    projectId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    buildId: string;
+    buildToken: string;
+}, {
+    projectId: string;
+    buildId: string;
+    buildToken: string;
+}>;
+export type ExternalBuildData = z.infer<typeof ExternalBuildData>;
+export 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, {
+        projectId: string;
+        buildId: string;
+        buildToken: string;
+    }, {
+        projectId: string;
+        buildId: string;
+        buildToken: string;
+    }>>>;
+    registryHost: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    id: string;
+    contentHash: string;
+    imageTag: string;
+    shortCode: string;
+    externalBuildData?: {
+        projectId: string;
+        buildId: string;
+        buildToken: string;
+    } | null | undefined;
+    registryHost?: string | undefined;
+}, {
+    version: string;
+    id: string;
+    contentHash: string;
+    imageTag: string;
+    shortCode: string;
+    externalBuildData?: {
+        projectId: string;
+        buildId: string;
+        buildToken: string;
+    } | null | undefined;
+    registryHost?: string | undefined;
+}>;
+export type InitializeDeploymentResponseBody = z.infer<typeof InitializeDeploymentResponseBody>;
+export declare const InitializeDeploymentRequestBody: z.ZodObject<{
+    contentHash: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+    registryHost: z.ZodOptional<z.ZodString>;
+    selfHosted: z.ZodOptional<z.ZodBoolean>;
+    namespace: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    contentHash: string;
+    userId?: string | undefined;
+    registryHost?: string | undefined;
+    selfHosted?: boolean | undefined;
+    namespace?: string | undefined;
+}, {
+    contentHash: string;
+    userId?: string | undefined;
+    registryHost?: string | undefined;
+    selfHosted?: boolean | undefined;
+    namespace?: string | undefined;
+}>;
+export type InitializeDeploymentRequestBody = z.infer<typeof InitializeDeploymentRequestBody>;
+export 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;
+}>;
+export type DeploymentErrorData = z.infer<typeof DeploymentErrorData>;
+export declare const FailDeploymentRequestBody: z.ZodObject<{
+    error: 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;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    };
+}, {
+    error: {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    };
+}>;
+export type FailDeploymentRequestBody = z.infer<typeof FailDeploymentRequestBody>;
+export declare const FailDeploymentResponseBody: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type FailDeploymentResponseBody = z.infer<typeof FailDeploymentResponseBody>;
+export 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.ZodNullable<z.ZodString>>;
+    errorData: z.ZodOptional<z.ZodNullable<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;
+            slug: string;
+            filePath: string;
+            exportName: string;
+        }, {
+            id: string;
+            slug: string;
+            filePath: string;
+            exportName: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        id: string;
+        tasks: {
+            id: string;
+            slug: string;
+            filePath: string;
+            exportName: string;
+        }[];
+    }, {
+        version: string;
+        id: string;
+        tasks: {
+            id: string;
+            slug: string;
+            filePath: string;
+            exportName: string;
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: "PENDING" | "CANCELED" | "TIMED_OUT" | "FAILED" | "BUILDING" | "DEPLOYING" | "DEPLOYED";
+    version: string;
+    id: string;
+    contentHash: string;
+    shortCode: string;
+    imageReference?: string | null | undefined;
+    errorData?: {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    } | null | undefined;
+    worker?: {
+        version: string;
+        id: string;
+        tasks: {
+            id: string;
+            slug: string;
+            filePath: string;
+            exportName: string;
+        }[];
+    } | undefined;
+}, {
+    status: "PENDING" | "CANCELED" | "TIMED_OUT" | "FAILED" | "BUILDING" | "DEPLOYING" | "DEPLOYED";
+    version: string;
+    id: string;
+    contentHash: string;
+    shortCode: string;
+    imageReference?: string | null | undefined;
+    errorData?: {
+        message: string;
+        name: string;
+        stack?: string | undefined;
+        stderr?: string | undefined;
+    } | null | undefined;
+    worker?: {
+        version: string;
+        id: string;
+        tasks: {
+            id: string;
+            slug: string;
+            filePath: string;
+            exportName: string;
+        }[];
+    } | undefined;
+}>;
+export type GetDeploymentResponseBody = z.infer<typeof GetDeploymentResponseBody>;
+export declare const CreateUploadPayloadUrlResponseBody: z.ZodObject<{
+    presignedUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    presignedUrl: string;
+}, {
+    presignedUrl: string;
+}>;
+export type CreateUploadPayloadUrlResponseBody = z.infer<typeof CreateUploadPayloadUrlResponseBody>;
+export declare const ReplayRunResponse: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type ReplayRunResponse = z.infer<typeof ReplayRunResponse>;
+export declare const CanceledRunResponse: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type CanceledRunResponse = z.infer<typeof CanceledRunResponse>;
+export declare const ScheduleType: z.ZodUnion<[z.ZodLiteral<"DECLARATIVE">, z.ZodLiteral<"IMPERATIVE">]>;
+export 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;
+    /** The type of schedule – `"DECLARATIVE"` or `"IMPERATIVE"`.
+     *
+     * **DECLARATIVE** – defined inline on your `schedules.task` using the `cron` property. They can only be created, updated or deleted by modifying the `cron` property on your task.
+     *
+     * **IMPERATIVE** – created using the `schedules.create` functions or in the dashboard.
+     */
+    type: z.ZodUnion<[z.ZodLiteral<"DECLARATIVE">, z.ZodLiteral<"IMPERATIVE">]>;
+    /** 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, {
+    type: "DECLARATIVE" | "IMPERATIVE";
+    timestamp: Date;
+    timezone: string;
+    scheduleId: string;
+    upcoming: Date[];
+    lastTimestamp?: Date | undefined;
+    externalId?: string | undefined;
+}, {
+    type: "DECLARATIVE" | "IMPERATIVE";
+    timestamp: Date;
+    timezone: string;
+    scheduleId: string;
+    upcoming: Date[];
+    lastTimestamp?: Date | undefined;
+    externalId?: string | undefined;
+}>;
+export type ScheduledTaskPayload = z.infer<typeof ScheduledTaskPayload>;
+export 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, {
+    cron: string;
+    task: string;
+    deduplicationKey: string;
+    externalId?: string | undefined;
+    timezone?: string | undefined;
+}, {
+    cron: string;
+    task: string;
+    deduplicationKey: string;
+    externalId?: string | undefined;
+    timezone?: string | undefined;
+}>;
+export type CreateScheduleOptions = z.infer<typeof CreateScheduleOptions>;
+export 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, {
+    cron: string;
+    task: string;
+    timezone?: string | undefined;
+    externalId?: string | undefined;
+}, {
+    cron: string;
+    task: string;
+    timezone?: string | undefined;
+    externalId?: string | undefined;
+}>;
+export type UpdateScheduleOptions = z.infer<typeof UpdateScheduleOptions>;
+export declare const ScheduleGenerator: z.ZodObject<{
+    type: z.ZodLiteral<"CRON">;
+    expression: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "CRON";
+    description: string;
+    expression: string;
+}, {
+    type: "CRON";
+    description: string;
+    expression: string;
+}>;
+export type ScheduleGenerator = z.infer<typeof ScheduleGenerator>;
+export declare const ScheduleObject: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodUnion<[z.ZodLiteral<"DECLARATIVE">, z.ZodLiteral<"IMPERATIVE">]>;
+    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";
+        description: string;
+        expression: string;
+    }, {
+        type: "CRON";
+        description: string;
+        expression: 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, {
+    type: "DECLARATIVE" | "IMPERATIVE";
+    id: string;
+    active: boolean;
+    task: string;
+    timezone: string;
+    generator: {
+        type: "CRON";
+        description: string;
+        expression: string;
+    };
+    environments: {
+        type: string;
+        id: string;
+        userName?: string | null | undefined;
+    }[];
+    deduplicationKey?: string | null | undefined;
+    externalId?: string | null | undefined;
+    nextRun?: Date | null | undefined;
+}, {
+    type: "DECLARATIVE" | "IMPERATIVE";
+    id: string;
+    active: boolean;
+    task: string;
+    timezone: string;
+    generator: {
+        type: "CRON";
+        description: string;
+        expression: string;
+    };
+    environments: {
+        type: string;
+        id: string;
+        userName?: string | null | undefined;
+    }[];
+    deduplicationKey?: string | null | undefined;
+    externalId?: string | null | undefined;
+    nextRun?: Date | null | undefined;
+}>;
+export type ScheduleObject = z.infer<typeof ScheduleObject>;
+export declare const DeletedScheduleObject: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type DeletedScheduleObject = z.infer<typeof DeletedScheduleObject>;
+export declare const ListSchedulesResult: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodUnion<[z.ZodLiteral<"DECLARATIVE">, z.ZodLiteral<"IMPERATIVE">]>;
+        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";
+            description: string;
+            expression: string;
+        }, {
+            type: "CRON";
+            description: string;
+            expression: 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, {
+        type: "DECLARATIVE" | "IMPERATIVE";
+        id: string;
+        active: boolean;
+        task: string;
+        timezone: string;
+        generator: {
+            type: "CRON";
+            description: string;
+            expression: string;
+        };
+        environments: {
+            type: string;
+            id: string;
+            userName?: string | null | undefined;
+        }[];
+        deduplicationKey?: string | null | undefined;
+        externalId?: string | null | undefined;
+        nextRun?: Date | null | undefined;
+    }, {
+        type: "DECLARATIVE" | "IMPERATIVE";
+        id: string;
+        active: boolean;
+        task: string;
+        timezone: string;
+        generator: {
+            type: "CRON";
+            description: string;
+            expression: 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: {
+        type: "DECLARATIVE" | "IMPERATIVE";
+        id: string;
+        active: boolean;
+        task: string;
+        timezone: string;
+        generator: {
+            type: "CRON";
+            description: string;
+            expression: 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: {
+        type: "DECLARATIVE" | "IMPERATIVE";
+        id: string;
+        active: boolean;
+        task: string;
+        timezone: string;
+        generator: {
+            type: "CRON";
+            description: string;
+            expression: 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;
+    };
+}>;
+export type ListSchedulesResult = z.infer<typeof ListSchedulesResult>;
+export 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;
+}>;
+export type ListScheduleOptions = z.infer<typeof ListScheduleOptions>;
+export declare const TimezonesResult: z.ZodObject<{
+    timezones: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    timezones: string[];
+}, {
+    timezones: string[];
+}>;
+export type TimezonesResult = z.infer<typeof TimezonesResult>;
+export declare const RunStatus: z.ZodEnum<["WAITING_FOR_DEPLOY", "QUEUED", "EXECUTING", "REATTEMPTING", "FROZEN", "COMPLETED", "CANCELED", "FAILED", "CRASHED", "INTERRUPTED", "SYSTEM_FAILURE", "DELAYED", "EXPIRED"]>;
+export type RunStatus = z.infer<typeof RunStatus>;
+export declare const AttemptStatus: z.ZodEnum<["PENDING", "EXECUTING", "PAUSED", "COMPLETED", "FAILED", "CANCELED"]>;
+export type AttemptStatus = z.infer<typeof AttemptStatus>;
+export declare const RunEnvironmentDetails: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    user: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    user?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    user?: string | undefined;
+}>;
+export type RunEnvironmentDetails = z.infer<typeof RunEnvironmentDetails>;
+export 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";
+        description: string;
+        expression: string;
+    }, {
+        type: "CRON";
+        description: string;
+        expression: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    generator: {
+        type: "CRON";
+        description: string;
+        expression: string;
+    };
+    externalId?: string | undefined;
+    deduplicationKey?: string | undefined;
+}, {
+    id: string;
+    generator: {
+        type: "CRON";
+        description: string;
+        expression: string;
+    };
+    externalId?: string | undefined;
+    deduplicationKey?: string | undefined;
+}>;
+export type RunScheduleDetails = z.infer<typeof RunScheduleDetails>;
+export 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";
+            description: string;
+            expression: string;
+        }, {
+            type: "CRON";
+            description: string;
+            expression: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        generator: {
+            type: "CRON";
+            description: string;
+            expression: string;
+        };
+        externalId?: string | undefined;
+        deduplicationKey?: string | undefined;
+    }, {
+        id: string;
+        generator: {
+            type: "CRON";
+            description: string;
+            expression: 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" | "COMPLETED" | "CANCELED" | "EXECUTING" | "FAILED" | "PAUSED";
+        id: string;
+        updatedAt: Date;
+        createdAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    }, {
+        status: "PENDING" | "COMPLETED" | "CANCELED" | "EXECUTING" | "FAILED" | "PAUSED";
+        id: string;
+        updatedAt: Date;
+        createdAt: 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>;
+    tags: z.ZodArray<z.ZodString, "many">;
+    costInCents: z.ZodNumber;
+    baseCostInCents: z.ZodNumber;
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    attempts: ({
+        status: "PENDING" | "COMPLETED" | "CANCELED" | "EXECUTING" | "FAILED" | "PAUSED";
+        id: string;
+        updatedAt: Date;
+        createdAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    isTest: boolean;
+    createdAt: Date;
+    tags: string[];
+    durationMs: number;
+    costInCents: number;
+    baseCostInCents: number;
+    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";
+            description: string;
+            expression: 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: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    attempts: ({
+        status: "PENDING" | "COMPLETED" | "CANCELED" | "EXECUTING" | "FAILED" | "PAUSED";
+        id: string;
+        updatedAt: Date;
+        createdAt: Date;
+        startedAt?: Date | undefined;
+        completedAt?: Date | undefined;
+        error?: {
+            message: string;
+            name?: string | undefined;
+            stackTrace?: string | undefined;
+        } | undefined;
+    } | undefined)[];
+    updatedAt: Date;
+    isTest: boolean;
+    createdAt: Date;
+    tags: string[];
+    durationMs: number;
+    costInCents: number;
+    baseCostInCents: number;
+    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";
+            description: string;
+            expression: 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;
+}>;
+export type RetrieveRunResponse = z.infer<typeof RetrieveRunResponse>;
+export declare const ListRunResponseItem: z.ZodObject<{
+    env: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        user: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        user?: string | undefined;
+    }, {
+        name: string;
+        id: 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>;
+    tags: z.ZodArray<z.ZodString, "many">;
+    costInCents: z.ZodNumber;
+    baseCostInCents: z.ZodNumber;
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    updatedAt: Date;
+    isTest: boolean;
+    createdAt: Date;
+    tags: string[];
+    durationMs: number;
+    costInCents: number;
+    baseCostInCents: number;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    env: {
+        name: string;
+        id: 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: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+    id: string;
+    updatedAt: Date;
+    isTest: boolean;
+    createdAt: Date;
+    tags: string[];
+    durationMs: number;
+    costInCents: number;
+    baseCostInCents: number;
+    taskIdentifier: string;
+    isQueued: boolean;
+    isExecuting: boolean;
+    isCompleted: boolean;
+    isSuccess: boolean;
+    isFailed: boolean;
+    isCancelled: boolean;
+    env: {
+        name: string;
+        id: 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;
+}>;
+export type ListRunResponseItem = z.infer<typeof ListRunResponseItem>;
+export 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, {
+            name: string;
+            id: string;
+            user?: string | undefined;
+        }, {
+            name: string;
+            id: 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>;
+        tags: z.ZodArray<z.ZodString, "many">;
+        costInCents: z.ZodNumber;
+        baseCostInCents: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        updatedAt: Date;
+        isTest: boolean;
+        createdAt: Date;
+        tags: string[];
+        durationMs: number;
+        costInCents: number;
+        baseCostInCents: number;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            name: string;
+            id: 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: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        updatedAt: Date;
+        isTest: boolean;
+        createdAt: Date;
+        tags: string[];
+        durationMs: number;
+        costInCents: number;
+        baseCostInCents: number;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            name: string;
+            id: 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: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        updatedAt: Date;
+        isTest: boolean;
+        createdAt: Date;
+        tags: string[];
+        durationMs: number;
+        costInCents: number;
+        baseCostInCents: number;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            name: string;
+            id: 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: "COMPLETED" | "CANCELED" | "QUEUED" | "EXECUTING" | "FAILED" | "WAITING_FOR_DEPLOY" | "REATTEMPTING" | "FROZEN" | "CRASHED" | "INTERRUPTED" | "SYSTEM_FAILURE" | "DELAYED" | "EXPIRED";
+        id: string;
+        updatedAt: Date;
+        isTest: boolean;
+        createdAt: Date;
+        tags: string[];
+        durationMs: number;
+        costInCents: number;
+        baseCostInCents: number;
+        taskIdentifier: string;
+        isQueued: boolean;
+        isExecuting: boolean;
+        isCompleted: boolean;
+        isSuccess: boolean;
+        isFailed: boolean;
+        isCancelled: boolean;
+        env: {
+            name: string;
+            id: 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;
+    };
+}>;
+export type ListRunResponse = z.infer<typeof ListRunResponse>;
+export declare const CreateEnvironmentVariableRequestBody: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    name: string;
+}, {
+    value: string;
+    name: string;
+}>;
+export type CreateEnvironmentVariableRequestBody = z.infer<typeof CreateEnvironmentVariableRequestBody>;
+export declare const UpdateEnvironmentVariableRequestBody: z.ZodObject<{
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+}, {
+    value: string;
+}>;
+export type UpdateEnvironmentVariableRequestBody = z.infer<typeof UpdateEnvironmentVariableRequestBody>;
+export 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;
+}>;
+export type ImportEnvironmentVariablesRequestBody = z.infer<typeof ImportEnvironmentVariablesRequestBody>;
+export declare const EnvironmentVariableResponseBody: z.ZodObject<{
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+}, {
+    success: boolean;
+}>;
+export type EnvironmentVariableResponseBody = z.infer<typeof EnvironmentVariableResponseBody>;
+export declare const EnvironmentVariableValue: z.ZodObject<{
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+}, {
+    value: string;
+}>;
+export type EnvironmentVariableValue = z.infer<typeof EnvironmentVariableValue>;
+export declare const EnvironmentVariable: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    name: string;
+}, {
+    value: string;
+    name: string;
+}>;
+export 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">;
+export type EnvironmentVariables = z.infer<typeof EnvironmentVariables>;