@trigger.dev/core 0.0.0-v3-prerelease-20250108142426 → 0.0.0-v4-prerelease-20250917185130

package/dist/esm/v3/schemas/api.js

@@ -1,16 +1,26 @@
 import { z } from "zod";
 import { DeserializedJsonSchema } from "../../schemas/json.js";
-import { FlushedRunMetadata, SerializedError, TaskRunError, } from "./common.js";
+import { FlushedRunMetadata, GitMeta, MachinePresetName, SerializedError, TaskRunError, } from "./common.js";
 import { BackgroundWorkerMetadata } from "./resources.js";
-import { QueueOptions } from "./schemas.js";
+import { DequeuedMessage, MachineResources } from "./runEngine.js";
+export const RunEngineVersion = z.union([z.literal("V1"), z.literal("V2")]);
 export const WhoAmIResponseSchema = z.object({
     userId: z.string(),
     email: z.string().email(),
     dashboardUrl: z.string(),
+    project: z
+        .object({
+        name: z.string(),
+        url: z.string(),
+        orgTitle: z.string(),
+    })
+        .optional(),
 });
 export const GetProjectResponseBody = z.object({
     id: z.string(),
-    externalRef: z.string(),
+    externalRef: z
+        .string()
+        .describe("The external reference for the project, also known as the project ref, a unique identifier starting with proj_"),
     name: z.string(),
     slug: z.string(),
     createdAt: z.coerce.date(),
@@ -22,16 +32,65 @@ export const GetProjectResponseBody = z.object({
     }),
 });
 export const GetProjectsResponseBody = z.array(GetProjectResponseBody);
+export const GetOrgsResponseBody = z.array(z.object({
+    id: z.string(),
+    title: z.string(),
+    slug: z.string(),
+    createdAt: z.coerce.date(),
+}));
+export const CreateProjectRequestBody = z.object({
+    name: z
+        .string()
+        .trim()
+        .min(1, "Name is required")
+        .max(255, "Name must be less than 255 characters"),
+});
 export const GetProjectEnvResponse = z.object({
     apiKey: z.string(),
     name: z.string(),
     apiUrl: z.string(),
     projectId: z.string(),
 });
+// Zod schema for the response body type
+export const GetWorkerTaskResponse = z.object({
+    id: z.string(),
+    slug: z.string(),
+    filePath: z.string(),
+    triggerSource: z.string(),
+    createdAt: z.coerce.date(),
+    payloadSchema: z.any().nullish(),
+});
+export const GetWorkerByTagResponse = z.object({
+    worker: z.object({
+        id: z.string(),
+        version: z.string(),
+        engine: z.string().nullish(),
+        sdkVersion: z.string().nullish(),
+        cliVersion: z.string().nullish(),
+        tasks: z.array(GetWorkerTaskResponse),
+    }),
+    urls: z.object({
+        runs: z.string(),
+    }),
+});
+export const GetJWTRequestBody = z.object({
+    claims: z
+        .object({
+        scopes: z.array(z.string()).default([]),
+    })
+        .optional(),
+    expirationTime: z.union([z.number(), z.string()]).optional(),
+});
+export const GetJWTResponse = z.object({
+    token: z.string(),
+});
 export const CreateBackgroundWorkerRequestBody = z.object({
     localOnly: z.boolean(),
     metadata: BackgroundWorkerMetadata,
+    engine: RunEngineVersion.optional(),
     supportsLazyAttempts: z.boolean().optional(),
+    buildPlatform: z.string().optional(),
+    targetPlatform: z.string().optional(),
 });
 export const CreateBackgroundWorkerResponse = z.object({
     id: z.string(),
@@ -46,29 +105,60 @@ export const TriggerTaskRequestBody = z.object({
     context: z.any(),
     options: z
         .object({
+        /** @deprecated engine v1 only */
         dependentAttempt: z.string().optional(),
+        /** @deprecated engine v1 only */
         parentAttempt: z.string().optional(),
+        /** @deprecated engine v1 only */
         dependentBatch: z.string().optional(),
+        /**
+         * If triggered in a batch, this is the BatchTaskRun id
+         */
         parentBatch: z.string().optional(),
+        /**
+         * RunEngine v2
+         * If triggered inside another run, the parentRunId is the friendly ID of the parent run.
+         */
+        parentRunId: z.string().optional(),
+        /**
+         * RunEngine v2
+         * Should be `true` if `triggerAndWait` or `batchTriggerAndWait`
+         */
+        resumeParentOnCompletion: z.boolean().optional(),
+        /**
+         * Locks the version to the passed value.
+         * Automatically set when using `triggerAndWait` or `batchTriggerAndWait`
+         */
         lockToVersion: z.string().optional(),
-        queue: QueueOptions.optional(),
+        queue: z
+            .object({
+            name: z.string(),
+            // @deprecated, this is now specified on the queue
+            concurrencyLimit: z.number().int().optional(),
+        })
+            .optional(),
         concurrencyKey: z.string().optional(),
+        delay: z.string().or(z.coerce.date()).optional(),
         idempotencyKey: z.string().optional(),
         idempotencyKeyTTL: z.string().optional(),
-        test: z.boolean().optional(),
-        payloadType: z.string().optional(),
-        delay: z.string().or(z.coerce.date()).optional(),
-        ttl: z.string().or(z.number().nonnegative().int()).optional(),
-        tags: RunTags.optional(),
+        machine: MachinePresetName.optional(),
         maxAttempts: z.number().int().optional(),
+        maxDuration: z.number().optional(),
         metadata: z.any(),
         metadataType: z.string().optional(),
-        maxDuration: z.number().optional(),
+        payloadType: z.string().optional(),
+        tags: RunTags.optional(),
+        test: z.boolean().optional(),
+        ttl: z.string().or(z.number().nonnegative().int()).optional(),
+        priority: z.number().optional(),
+        bulkActionId: z.string().optional(),
+        region: z.string().optional(),
     })
         .optional(),
 });
 export const TriggerTaskResponse = z.object({
     id: z.string(),
+    isCached: z.boolean().optional(),
 });
 export const BatchTriggerTaskRequestBody = z.object({
     items: TriggerTaskRequestBody.array(),
@@ -80,27 +170,45 @@ export const BatchTriggerTaskItem = z.object({
     context: z.any(),
     options: z
         .object({
-        lockToVersion: z.string().optional(),
-        queue: QueueOptions.optional(),
         concurrencyKey: z.string().optional(),
+        delay: z.string().or(z.coerce.date()).optional(),
         idempotencyKey: z.string().optional(),
         idempotencyKeyTTL: z.string().optional(),
-        test: z.boolean().optional(),
-        payloadType: z.string().optional(),
-        delay: z.string().or(z.coerce.date()).optional(),
-        ttl: z.string().or(z.number().nonnegative().int()).optional(),
-        tags: RunTags.optional(),
+        lockToVersion: z.string().optional(),
+        machine: MachinePresetName.optional(),
         maxAttempts: z.number().int().optional(),
+        maxDuration: z.number().optional(),
         metadata: z.any(),
         metadataType: z.string().optional(),
-        maxDuration: z.number().optional(),
         parentAttempt: z.string().optional(),
+        payloadType: z.string().optional(),
+        queue: z
+            .object({
+            name: z.string(),
+        })
+            .optional(),
+        tags: RunTags.optional(),
+        test: z.boolean().optional(),
+        ttl: z.string().or(z.number().nonnegative().int()).optional(),
+        priority: z.number().optional(),
+        region: z.string().optional(),
     })
         .optional(),
 });
 export const BatchTriggerTaskV2RequestBody = z.object({
     items: BatchTriggerTaskItem.array(),
+    /** @deprecated engine v1 only */
     dependentAttempt: z.string().optional(),
+    /**
+     * RunEngine v2
+     * If triggered inside another run, the parentRunId is the friendly ID of the parent run.
+     */
+    parentRunId: z.string().optional(),
+    /**
+     * RunEngine v2
+     * Should be `true` if `triggerAndWait` or `batchTriggerAndWait`
+     */
+    resumeParentOnCompletion: z.boolean().optional(),
 });
 export const BatchTriggerTaskV2Response = z.object({
     id: z.string(),
@@ -113,6 +221,23 @@ export const BatchTriggerTaskV2Response = z.object({
         idempotencyKey: z.string().optional(),
     })),
 });
+export const BatchTriggerTaskV3RequestBody = z.object({
+    items: BatchTriggerTaskItem.array(),
+    /**
+     * RunEngine v2
+     * If triggered inside another run, the parentRunId is the friendly ID of the parent run.
+     */
+    parentRunId: z.string().optional(),
+    /**
+     * RunEngine v2
+     * Should be `true` if `triggerAndWait` or `batchTriggerAndWait`
+     */
+    resumeParentOnCompletion: z.boolean().optional(),
+});
+export const BatchTriggerTaskV3Response = z.object({
+    id: z.string(),
+    runCount: z.number(),
+});
 export const BatchTriggerTaskResponse = z.object({
     batchId: z.string(),
     runs: z.string().array(),
@@ -143,29 +268,39 @@ export const StartDeploymentIndexingResponseBody = z.object({
     contentHash: z.string(),
 });
 export const FinalizeDeploymentRequestBody = z.object({
-    imageReference: z.string(),
-    selfHosted: z.boolean().optional(),
+    skipPromotion: z.boolean().optional(),
+    imageDigest: z.string().optional(),
 });
 export const ExternalBuildData = z.object({
     buildId: z.string(),
     buildToken: z.string(),
     projectId: z.string(),
 });
+export const UpsertBranchRequestBody = z.object({
+    git: GitMeta.optional(),
+    env: z.enum(["preview"]),
+    branch: z.string(),
+});
+export const UpsertBranchResponseBody = z.object({
+    id: z.string(),
+});
 export const InitializeDeploymentResponseBody = z.object({
     id: z.string(),
     contentHash: z.string(),
     shortCode: z.string(),
     version: z.string(),
     imageTag: z.string(),
+    imagePlatform: z.string(),
     externalBuildData: ExternalBuildData.optional().nullable(),
-    registryHost: z.string().optional(),
 });
 export const InitializeDeploymentRequestBody = z.object({
     contentHash: z.string(),
     userId: z.string().optional(),
-    registryHost: z.string().optional(),
+    /** @deprecated This is now determined by the webapp. This is only used to warn users with old CLI versions. */
     selfHosted: z.boolean().optional(),
-    namespace: z.string().optional(),
+    gitMeta: GitMeta.optional(),
+    type: z.enum(["MANAGED", "UNMANAGED", "V1"]).optional(),
+    runtime: z.string().optional(),
 });
 export const DeploymentErrorData = z.object({
     name: z.string(),
@@ -179,6 +314,11 @@ export const FailDeploymentRequestBody = z.object({
 export const FailDeploymentResponseBody = z.object({
     id: z.string(),
 });
+export const PromoteDeploymentResponseBody = z.object({
+    id: z.string(),
+    version: z.string(),
+    shortCode: z.string(),
+});
 export const GetDeploymentResponseBody = z.object({
     id: z.string(),
     status: z.enum([
@@ -194,6 +334,8 @@ export const GetDeploymentResponseBody = z.object({
     shortCode: z.string(),
     version: z.string(),
     imageReference: z.string().nullish(),
+    imagePlatform: z.string(),
+    externalBuildData: ExternalBuildData.optional().nullable(),
     errorData: DeploymentErrorData.nullish(),
     worker: z
         .object({
@@ -203,14 +345,56 @@ export const GetDeploymentResponseBody = z.object({
             id: z.string(),
             slug: z.string(),
             filePath: z.string(),
-            exportName: z.string(),
+            exportName: z.string().optional(),
         })),
     })
         .optional(),
 });
+export const GetLatestDeploymentResponseBody = GetDeploymentResponseBody.omit({
+    worker: true,
+});
 export const CreateUploadPayloadUrlResponseBody = z.object({
     presignedUrl: z.string(),
 });
+export const WorkersListResponseBody = z
+    .object({
+    type: z.string(),
+    name: z.string(),
+    description: z.string().nullish(),
+    latestVersion: z.string().nullish(),
+    lastHeartbeatAt: z.string().nullish(),
+    isDefault: z.boolean(),
+    updatedAt: z.coerce.date(),
+})
+    .array();
+export const WorkersCreateRequestBody = z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+});
+export const WorkersCreateResponseBody = z.object({
+    workerGroup: z.object({
+        name: z.string(),
+        description: z.string().nullish(),
+    }),
+    token: z.object({
+        plaintext: z.string(),
+    }),
+});
+export const DevConfigResponseBody = z.object({
+    environmentId: z.string(),
+    dequeueIntervalWithRun: z.number(),
+    dequeueIntervalWithoutRun: z.number(),
+    maxConcurrentRuns: z.number(),
+    engineUrl: z.string(),
+});
+export const DevDequeueRequestBody = z.object({
+    currentWorker: z.string(),
+    oldWorkers: z.string().array(),
+    maxResources: MachineResources.optional(),
+});
+export const DevDequeueResponseBody = z.object({
+    dequeuedMessages: DequeuedMessage.array(),
+});
 export const ReplayRunResponse = z.object({
     id: z.string(),
 });
@@ -335,16 +519,16 @@ export const TimezonesResult = z.object({
     timezones: z.array(z.string()),
 });
 export const RunStatus = z.enum([
-    /// Task hasn't been deployed yet but is waiting to be executed
-    "WAITING_FOR_DEPLOY",
+    /// Task is waiting for a version update because it cannot execute without additional information (task, queue, etc.)
+    "PENDING_VERSION",
     /// Task is waiting to be executed by a worker
     "QUEUED",
+    /// Task is waiting to be executed by a worker
+    "DEQUEUED",
     /// Task is currently being executed by a worker
     "EXECUTING",
-    /// Task has failed and is waiting to be retried
-    "REATTEMPTING",
     /// Task has been paused by the system, and will be resumed by the system
-    "FROZEN",
+    "WAITING",
     /// Task has been completed successfully
     "COMPLETED",
     /// Task has been canceled by the user
@@ -353,8 +537,6 @@ export const RunStatus = z.enum([
     "FAILED",
     /// Task has crashed and won't be retried, most likely the worker ran out of resources, e.g. memory or storage
     "CRASHED",
-    /// Task was interrupted during execution, mostly this happens in development environments
-    "INTERRUPTED",
     /// Task has failed to complete, due to an error in the system
     "SYSTEM_FAILURE",
     /// Task has been scheduled to run at a specific time
@@ -397,6 +579,7 @@ const CommonRunFields = {
     version: z.string().optional(),
     isQueued: z.boolean(),
     isExecuting: z.boolean(),
+    isWaiting: z.boolean(),
     isCompleted: z.boolean(),
     isSuccess: z.boolean(),
     isFailed: z.boolean(),
@@ -435,17 +618,6 @@ export const RetrieveRunResponse = z.object({
         parent: RelatedRunDetails.optional(),
         children: z.array(RelatedRunDetails).optional(),
     }),
-    attempts: z.array(z
-        .object({
-        id: z.string(),
-        status: AttemptStatus,
-        createdAt: z.coerce.date(),
-        updatedAt: z.coerce.date(),
-        startedAt: z.coerce.date().optional(),
-        completedAt: z.coerce.date().optional(),
-        error: SerializedError.optional(),
-    })
-        .optional()),
     attemptCount: z.number().default(0),
 });
 export const ListRunResponseItem = z.object({
@@ -468,6 +640,7 @@ export const UpdateEnvironmentVariableRequestBody = z.object({
 });
 export const ImportEnvironmentVariablesRequestBody = z.object({
     variables: z.record(z.string()),
+    parentVariables: z.record(z.string()).optional(),
     override: z.boolean().optional(),
 });
 export const EnvironmentVariableResponseBody = z.object({
@@ -481,6 +654,20 @@ export const EnvironmentVariable = z.object({
     value: z.string(),
 });
 export const EnvironmentVariables = z.array(EnvironmentVariable);
+export const EnvironmentVariableWithSecret = z.object({
+    /** The name of the env var, e.g. `DATABASE_URL` */
+    name: z.string(),
+    /** The value of the env var. If it's a secret, this will be a redacted value, not the real value.  */
+    value: z.string(),
+    /**
+     * Whether the env var is a secret or not.
+     * When you create env vars you can mark them as secrets.
+     *
+     * You can't view the value of a secret env var after setting it initially.
+     * For a secret env var, the value will be redacted.
+     */
+    isSecret: z.boolean(),
+});
 export const UpdateMetadataRequestBody = FlushedRunMetadata;
 export const UpdateMetadataResponseBody = z.object({
     metadata: z.record(DeserializedJsonSchema),
@@ -495,7 +682,9 @@ const RawOptionalShapeDate = z
     .transform((val) => (val ? new Date(`${val}Z`) : val));
 export const SubscribeRunRawShape = z.object({
     id: z.string(),
-    idempotencyKey: z.string().nullish(),
+    taskIdentifier: z.string(),
+    friendlyId: z.string(),
+    status: z.string(),
     createdAt: RawShapeDate,
     updatedAt: RawShapeDate,
     startedAt: RawOptionalShapeDate,
@@ -503,14 +692,12 @@ export const SubscribeRunRawShape = z.object({
     queuedAt: RawOptionalShapeDate,
     expiredAt: RawOptionalShapeDate,
     completedAt: RawOptionalShapeDate,
-    taskIdentifier: z.string(),
-    friendlyId: z.string(),
-    number: z.number(),
-    isTest: z.boolean(),
-    status: z.string(),
-    usageDurationMs: z.number(),
-    costInCents: z.number(),
-    baseCostInCents: z.number(),
+    idempotencyKey: z.string().nullish(),
+    number: z.number().default(0),
+    isTest: z.boolean().default(false),
+    usageDurationMs: z.number().default(0),
+    costInCents: z.number().default(0),
+    baseCostInCents: z.number().default(0),
     ttl: z.string().nullish(),
     payload: z.string().nullish(),
     payloadType: z.string().nullish(),
@@ -529,6 +716,16 @@ export const RetrieveBatchResponse = z.object({
     createdAt: z.coerce.date(),
     updatedAt: z.coerce.date(),
     runCount: z.number(),
+    runs: z.array(z.string()),
+});
+export const RetrieveBatchV2Response = z.object({
+    id: z.string(),
+    status: BatchStatus,
+    idempotencyKey: z.string().optional(),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+    runCount: z.number(),
+    runs: z.array(z.string()),
 });
 export const SubscribeRealtimeStreamChunkRawShape = z.object({
     id: z.string(),
@@ -538,4 +735,212 @@ export const SubscribeRealtimeStreamChunkRawShape = z.object({
     value: z.string(),
     createdAt: z.coerce.date(),
 });
+export const TimePeriod = z.string().or(z.coerce.date());
+export const CreateWaitpointTokenRequestBody = z.object({
+    /**
+     * An optional idempotency key for the waitpoint.
+     * If you use the same key twice (and the key hasn't expired), you will get the original waitpoint back.
+     *
+     * Note: This waitpoint may already be complete, in which case when you wait for it, it will immediately continue.
+     */
+    idempotencyKey: z.string().optional(),
+    /**
+     * When set, this means the passed in idempotency key will expire after this time.
+     * This means after that time if you pass the same idempotency key again, you will get a new waitpoint.
+     */
+    idempotencyKeyTTL: z.string().optional(),
+    /** The resume token will timeout after this time.
+     * If you are waiting for the token in a run, the token will return a result where `ok` is false.
+     *
+     * You can pass a `Date` object, or a string in this format: "30s", "1m", "2h", "3d", "4w".
+     */
+    timeout: TimePeriod.optional(),
+    /**
+     * Tags to attach to the waitpoint. Tags can be used to filter waitpoints in the dashboard.
+     *
+     * You can set up to 10 tags per waitpoint, they must be less than 128 characters each.
+     *
+     * We recommend prefixing tags with a namespace using an underscore or colon, like `user_1234567` or `org:9876543`.
+     *
+     * @example
+     *
+     * ```ts
+     * await wait.createToken({ tags: ["user:1234567", "org:9876543"] });
+     * ```
+     */
+    tags: RunTags.optional(),
+});
+export const CreateWaitpointTokenResponseBody = z.object({
+    id: z.string(),
+    isCached: z.boolean(),
+    url: z.string(),
+});
+export const waitpointTokenStatuses = ["WAITING", "COMPLETED", "TIMED_OUT"];
+export const WaitpointTokenStatus = z.enum(waitpointTokenStatuses);
+export const WaitpointTokenItem = z.object({
+    id: z.string(),
+    /** If you make a POST request to this URL, it will complete the waitpoint. */
+    url: z.string(),
+    status: WaitpointTokenStatus,
+    completedAt: z.coerce.date().optional(),
+    completedAfter: z.coerce.date().optional(),
+    timeoutAt: z.coerce.date().optional(),
+    idempotencyKey: z.string().optional(),
+    idempotencyKeyExpiresAt: z.coerce.date().optional(),
+    tags: z.array(z.string()),
+    createdAt: z.coerce.date(),
+});
+export const WaitpointListTokenItem = WaitpointTokenItem.omit({
+    completedAfter: true,
+});
+export const WaitpointRetrieveTokenResponse = WaitpointListTokenItem.and(z.object({
+    output: z.string().optional(),
+    outputType: z.string().optional(),
+    outputIsError: z.boolean().optional(),
+}));
+export const CompleteWaitpointTokenRequestBody = z.object({
+    data: z.any().nullish(),
+});
+export const CompleteWaitpointTokenResponseBody = z.object({
+    success: z.literal(true),
+});
+export const WaitForWaitpointTokenResponseBody = z.object({
+    success: z.boolean(),
+});
+export const WaitForDurationRequestBody = z.object({
+    /**
+     * An optional idempotency key for the waitpoint.
+     * If you use the same key twice (and the key hasn't expired), you will get the original waitpoint back.
+     *
+     * Note: This waitpoint may already be complete, in which case when you wait for it, it will immediately continue.
+     */
+    idempotencyKey: z.string().optional(),
+    /**
+     * When set, this means the passed in idempotency key will expire after this time.
+     * This means after that time if you pass the same idempotency key again, you will get a new waitpoint.
+     */
+    idempotencyKeyTTL: z.string().optional(),
+    /**
+     * The date that the waitpoint will complete.
+     */
+    date: z.coerce.date(),
+});
+export const WaitForDurationResponseBody = z.object({
+    /**
+        If you pass an idempotencyKey, you may actually not need to wait.
+        Use this date to determine when to continue.
+    */
+    waitUntil: z.coerce.date(),
+    waitpoint: z.object({
+        id: z.string(),
+    }),
+});
+const WAITPOINT_TIMEOUT_ERROR_CODE = "TRIGGER_WAITPOINT_TIMEOUT";
+export function isWaitpointOutputTimeout(output) {
+    try {
+        const json = JSON.parse(output);
+        return json.code === WAITPOINT_TIMEOUT_ERROR_CODE;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function timeoutError(timeout) {
+    return {
+        code: WAITPOINT_TIMEOUT_ERROR_CODE,
+        message: `Waitpoint timed out at ${timeout.toISOString()}`,
+    };
+}
+const ApiDeploymentCommonShape = {
+    from: z.string().describe("The date to start the search from, in ISO 8601 format").optional(),
+    to: z.string().describe("The date to end the search, in ISO 8601 format").optional(),
+    period: z.string().describe("The period to search within (e.g. 1d, 7d, 3h, etc.)").optional(),
+    status: z
+        .enum(["PENDING", "BUILDING", "DEPLOYING", "DEPLOYED", "FAILED", "CANCELED", "TIMED_OUT"])
+        .describe("Filter deployments that are in this status")
+        .optional(),
+};
+const ApiDeploymentListPaginationCursor = z
+    .string()
+    .describe("The deployment ID to start the search from, to get the next page")
+    .optional();
+const ApiDeploymentListPaginationLimit = z.coerce
+    .number()
+    .describe("The number of deployments to return, defaults to 20 (max 100)")
+    .min(1, "Limit must be at least 1")
+    .max(100, "Limit must be less than 100")
+    .optional();
+export const ApiDeploymentListParams = {
+    ...ApiDeploymentCommonShape,
+    cursor: ApiDeploymentListPaginationCursor,
+    limit: ApiDeploymentListPaginationLimit,
+};
+export const ApiDeploymentListOptions = z.object(ApiDeploymentListParams);
+export const ApiDeploymentListSearchParams = z.object({
+    ...ApiDeploymentCommonShape,
+    "page[after]": ApiDeploymentListPaginationCursor,
+    "page[size]": ApiDeploymentListPaginationLimit,
+});
+export const ApiDeploymentListResponseItem = z.object({
+    id: z.string(),
+    createdAt: z.coerce.date(),
+    shortCode: z.string(),
+    version: z.string(),
+    runtime: z.string(),
+    runtimeVersion: z.string(),
+    status: z.enum([
+        "PENDING",
+        "BUILDING",
+        "DEPLOYING",
+        "DEPLOYED",
+        "FAILED",
+        "CANCELED",
+        "TIMED_OUT",
+    ]),
+    deployedAt: z.coerce.date().optional(),
+    git: z.record(z.any()).optional(),
+    error: DeploymentErrorData.optional(),
+});
+export const ApiBranchListResponseBody = z.object({
+    branches: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        createdAt: z.coerce.date(),
+        updatedAt: z.coerce.date(),
+        git: z.record(z.any()).optional(),
+        isPaused: z.boolean(),
+    })),
+});
+export const RetrieveRunTraceSpanSchema = z.object({
+    id: z.string(),
+    parentId: z.string().optional(),
+    message: z.string(),
+    data: z.object({
+        runId: z.string(),
+        taskSlug: z.string().optional(),
+        taskPath: z.string().optional(),
+        events: z.array(z.any()).optional(),
+        startTime: z.coerce.date(),
+        duration: z.number(),
+        isError: z.boolean(),
+        isPartial: z.boolean(),
+        isCancelled: z.boolean(),
+        level: z.string(),
+        environmentType: z.string(),
+        workerVersion: z.string().optional(),
+        queueName: z.string().optional(),
+        machinePreset: z.string().optional(),
+        properties: z.record(z.any()).optional(),
+        output: z.unknown().optional(),
+    }),
+});
+export const RetrieveRunTraceSpan = RetrieveRunTraceSpanSchema.extend({
+    children: z.lazy(() => RetrieveRunTraceSpan.array()),
+});
+export const RetrieveRunTraceResponseBody = z.object({
+    trace: z.object({
+        traceId: z.string(),
+        rootSpan: RetrieveRunTraceSpan,
+    }),
+});
 //# sourceMappingURL=api.js.map