@phpsandbox/sdk 0.0.56 → 0.0.58

package/dist/index.js

@@ -28,6 +28,7 @@ import Git from './git.js';
 import { createBeacon } from './beacon/index.js';
 import { NotebookUnavailableError } from './errors/index.js';
 import { DeploymentApi, NotebookDeploymentApi } from './deployments.js';
+import { ServerApi } from './servers.js';
 export * from './types.js';
 export { Transport } from './socket/index.js';
 export * from './lsp.js';
@@ -42,6 +43,7 @@ export * from './utils/promise.js';
 export * from './beacon/index.js';
 export * from './errors/index.js';
 export * from './deployments.js';
+export * from './servers.js';
 function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
         return input;
@@ -97,7 +99,7 @@ export class NotebookApi {
         this.secrets = new NotebookSecretApi(client);
         this.preview = new NotebookPreviewApi(client);
         this.mail = new NotebookMailApi(client);
-        this.deployments = new NotebookDeploymentApi(client);
+        this.deployment = new NotebookDeploymentApi(client);
     }
     async create(template, input = {}, init = true) {
         const response = await this.client.post('/notebook', { template, ...input });
@@ -151,6 +153,7 @@ export class Client {
         this.fetch = globalThis.fetch;
         this.deployments = new DeploymentApi(this);
         this.notebook = new NotebookApi(this);
+        this.servers = new ServerApi(this);
         this.options = Object.assign({ startClosed: true }, options);
         this.baseUrl = normalizeApiBaseUrl(url);
         if (options.fetch) {
@@ -187,6 +190,22 @@ export class Client {
         }
         return response.body;
     }
+    async sse(url) {
+        const response = await this.fetch(new Request(url, {
+            method: 'GET',
+            headers: {
+                ...this.headers,
+                'Accept': 'text/event-stream',
+            },
+        }));
+        if (!response.ok) {
+            throw new ApiError(response, await response.text());
+        }
+        if (!response.body) {
+            throw new Error('PHPSandbox API Error: SSE response body is not readable');
+        }
+        return response.body;
+    }
     async makeRequest(method, path, init) {
         const response = await this.fetch(new Request(new URL(path.replace(/^\//, ''), this.baseUrl), {
             method,
@@ -209,8 +228,12 @@ export class NotebookSecretApi {
     constructor(client) {
         this.client = client;
     }
-    async list(id) {
-        const response = await this.client.get(`/notebook/${id}/secrets`);
+    async list(id, options) {
+        const params = new URLSearchParams();
+        if (options?.environment)
+            params.set('environment', options.environment);
+        const query = params.toString();
+        const response = await this.client.get(`/notebook/${id}/secrets${query ? `?${query}` : ''}`);
         return response.data;
     }
     async set(id, name, input) {
@@ -224,8 +247,12 @@ export class NotebookSecretApi {
         });
         return response.data;
     }
-    async delete(id, name) {
-        await this.client.delete(`/notebook/${id}/secrets/${encodeURIComponent(name)}`);
+    async delete(id, name, options) {
+        const params = new URLSearchParams();
+        if (options?.environment)
+            params.set('environment', options.environment);
+        const query = params.toString();
+        await this.client.delete(`/notebook/${id}/secrets/${encodeURIComponent(name)}${query ? `?${query}` : ''}`);
     }
 }
 export class NotebookPreviewApi {
@@ -305,7 +332,7 @@ export class NotebookInstance {
         this.container = new Container(this);
         this.laravel = new Laravel(this);
         this.shell = new Shell(this);
-        this.git = new Git(this);
+        this.git = new Git(this, client);
         this.services = new Services(this);
         this.config = new Config(this);
         this.secrets = new NotebookSecrets(client, this.data.id);
@@ -334,8 +361,11 @@ export class NotebookInstance {
     fork(input = {}) {
         return this.client.notebook.fork(this.data.id, input);
     }
-    deploy(input = {}) {
-        return this.client.notebook.deployments.create(this.data.id, input);
+    deployment() {
+        return this.client.notebook.deployment.current(this.data.id);
+    }
+    publish(input) {
+        return this.client.notebook.deployment.publish(this.data.id, input);
     }
     gitCredentials() {
         return this.client.notebook.gitCredentials(this.data.id);
@@ -501,8 +531,8 @@ export class NotebookSecrets {
         this.client = client;
         this.notebookId = notebookId;
     }
-    list() {
-        return this.client.notebook.secrets.list(this.notebookId);
+    list(options) {
+        return this.client.notebook.secrets.list(this.notebookId, options);
     }
     set(name, input) {
         return this.client.notebook.secrets.set(this.notebookId, name, input);
@@ -510,8 +540,8 @@ export class NotebookSecrets {
     setMany(input) {
         return this.client.notebook.secrets.setMany(this.notebookId, input);
     }
-    delete(name) {
-        return this.client.notebook.secrets.delete(this.notebookId, name);
+    delete(name, options) {
+        return this.client.notebook.secrets.delete(this.notebookId, name, options);
     }
 }
 export class NotebookPreview {

package/dist/schemas/deployments.d.ts

@@ -0,0 +1,417 @@
+import { z } from 'zod';
+export declare const DeploymentTargetProviderSchema: z.ZodEnum<{
+    okraCloudflareContainer: "okraCloudflareContainer";
+    okraSshAgent: "okraSshAgent";
+    okraLaravelCloud: "okraLaravelCloud";
+}>;
+export declare const DeploymentStatusSchema: z.ZodEnum<{
+    stopped: "stopped";
+    deleted: "deleted";
+    pending: "pending";
+    queued: "queued";
+    building: "building";
+    deploying: "deploying";
+    healthy: "healthy";
+    failed: "failed";
+    deleting: "deleting";
+    delete_failed: "delete_failed";
+}>;
+export declare const DeploymentBuildStatusSchema: z.ZodEnum<{
+    running: "running";
+    pending: "pending";
+    queued: "queued";
+    failed: "failed";
+    succeeded: "succeeded";
+    cancelled: "cancelled";
+}>;
+export declare const DeploymentReleaseStatusSchema: z.ZodEnum<{
+    created: "created";
+    deleted: "deleted";
+    ready: "ready";
+}>;
+export declare const DeploymentSizeSchema: z.ZodEnum<{
+    small: "small";
+    basic: "basic";
+    nano: "nano";
+    medium: "medium";
+    large: "large";
+    lite: "lite";
+    "standard-1": "standard-1";
+    "standard-2": "standard-2";
+}>;
+export declare const DeploymentRegionSchema: z.ZodEnum<{
+    ENAM: "ENAM";
+    WNAM: "WNAM";
+    EEUR: "EEUR";
+    WEUR: "WEUR";
+    APAC: "APAC";
+    SAM: "SAM";
+    ME: "ME";
+    OC: "OC";
+    AFR: "AFR";
+}>;
+export declare const DeploymentJurisdictionSchema: z.ZodEnum<{
+    eu: "eu";
+    fedramp: "fedramp";
+}>;
+export declare const DeploymentDomainDnsRecordTypeSchema: z.ZodEnum<{
+    CNAME: "CNAME";
+    ALIAS: "ALIAS";
+    ANAME: "ANAME";
+}>;
+export declare const DeploymentProtectionModeSchema: z.ZodEnum<{
+    none: "none";
+    password: "password";
+}>;
+export declare const DeploymentLogStreamSchema: z.ZodEnum<{
+    build: "build";
+    runtime: "runtime";
+}>;
+export declare const DeployStreamLogStreamSchema: z.ZodEnum<{
+    build: "build";
+    runtime: "runtime";
+    deploy: "deploy";
+}>;
+export declare const DeploymentEventDataSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    sequence: z.ZodNumber;
+    type: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export declare const DeploymentLogChunkDataSchema: z.ZodObject<{
+    sequence: z.ZodNumber;
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+    }>;
+    content: z.ZodString;
+    createdAt: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export declare const DeployStreamPhaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const DeployStreamLogSchema: z.ZodObject<{
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+        deploy: "deploy";
+    }>;
+    content: z.ZodString;
+}, z.core.$strict>;
+export declare const DeployStreamResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    deploymentId: z.ZodString;
+    buildId: z.ZodString;
+    releaseId: z.ZodString;
+    status: z.ZodEnum<{
+        stopped: "stopped";
+        deleted: "deleted";
+        pending: "pending";
+        queued: "queued";
+        building: "building";
+        deploying: "deploying";
+        healthy: "healthy";
+        failed: "failed";
+        deleting: "deleting";
+        delete_failed: "delete_failed";
+    }>;
+}, z.core.$strict>;
+export declare const DeployStreamPhaseEventSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"phase">;
+}, z.core.$strict>;
+export declare const DeployStreamLogEventSchema: z.ZodObject<{
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+        deploy: "deploy";
+    }>;
+    content: z.ZodString;
+    type: z.ZodLiteral<"log">;
+}, z.core.$strict>;
+export declare const DeployStreamResultEventSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    deploymentId: z.ZodString;
+    buildId: z.ZodString;
+    releaseId: z.ZodString;
+    status: z.ZodEnum<{
+        stopped: "stopped";
+        deleted: "deleted";
+        pending: "pending";
+        queued: "queued";
+        building: "building";
+        deploying: "deploying";
+        healthy: "healthy";
+        failed: "failed";
+        deleting: "deleting";
+        delete_failed: "delete_failed";
+    }>;
+    type: z.ZodLiteral<"result">;
+}, z.core.$strict>;
+export declare const DeployStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+    }>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"phase">;
+}, z.core.$strict>, z.ZodObject<{
+    stream: z.ZodEnum<{
+        build: "build";
+        runtime: "runtime";
+        deploy: "deploy";
+    }>;
+    content: z.ZodString;
+    type: z.ZodLiteral<"log">;
+}, z.core.$strict>, z.ZodObject<{
+    success: z.ZodBoolean;
+    deploymentId: z.ZodString;
+    buildId: z.ZodString;
+    releaseId: z.ZodString;
+    status: z.ZodEnum<{
+        stopped: "stopped";
+        deleted: "deleted";
+        pending: "pending";
+        queued: "queued";
+        building: "building";
+        deploying: "deploying";
+        healthy: "healthy";
+        failed: "failed";
+        deleting: "deleting";
+        delete_failed: "delete_failed";
+    }>;
+    type: z.ZodLiteral<"result">;
+}, z.core.$strict>], "type">;
+export declare const DeployStreamErrorSchema: z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const DeployStreamSseEventNameSchema: z.ZodEnum<{
+    error: "error";
+    log: "log";
+    phase: "phase";
+    result: "result";
+    done: "done";
+}>;
+export declare const DeployStreamSsePhaseEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"phase">;
+    data: z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            completed: "completed";
+        }>>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseLogEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"log">;
+    data: z.ZodObject<{
+        stream: z.ZodEnum<{
+            build: "build";
+            runtime: "runtime";
+            deploy: "deploy";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseDoneEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"done">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseResultEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"result">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeployStreamSseErrorEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"error">;
+    data: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strict>;
+export declare const DeployStreamSseEventSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    event: z.ZodLiteral<"phase">;
+    data: z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            completed: "completed";
+        }>>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"log">;
+    data: z.ZodObject<{
+        stream: z.ZodEnum<{
+            build: "build";
+            runtime: "runtime";
+            deploy: "deploy";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"done">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"result">;
+    data: z.ZodObject<{
+        success: z.ZodBoolean;
+        deploymentId: z.ZodString;
+        buildId: z.ZodString;
+        releaseId: z.ZodString;
+        status: z.ZodEnum<{
+            stopped: "stopped";
+            deleted: "deleted";
+            pending: "pending";
+            queued: "queued";
+            building: "building";
+            deploying: "deploying";
+            healthy: "healthy";
+            failed: "failed";
+            deleting: "deleting";
+            delete_failed: "delete_failed";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"error">;
+    data: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strict>], "event">, z.ZodTransform<{
+    name: string;
+    type: "phase";
+    status?: "running" | "failed" | "completed";
+    data?: Record<string, unknown>;
+} | {
+    stream: "build" | "runtime" | "deploy";
+    content: string;
+    type: "log";
+} | {
+    success: boolean;
+    deploymentId: string;
+    buildId: string;
+    releaseId: string;
+    status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
+    type: "result";
+}, {
+    event: "phase";
+    data: {
+        name: string;
+        status?: "running" | "failed" | "completed";
+        data?: Record<string, unknown>;
+    };
+} | {
+    event: "log";
+    data: {
+        stream: "build" | "runtime" | "deploy";
+        content: string;
+    };
+} | {
+    event: "done";
+    data: {
+        success: boolean;
+        deploymentId: string;
+        buildId: string;
+        releaseId: string;
+        status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
+    };
+} | {
+    event: "result";
+    data: {
+        success: boolean;
+        deploymentId: string;
+        buildId: string;
+        releaseId: string;
+        status: "stopped" | "deleted" | "pending" | "queued" | "building" | "deploying" | "healthy" | "failed" | "deleting" | "delete_failed";
+    };
+} | {
+    event: "error";
+    data: {
+        [x: string]: unknown;
+        message?: string;
+    };
+}>>;
+export type DeploymentTargetProvider = z.infer<typeof DeploymentTargetProviderSchema>;
+export type DeploymentStatus = z.infer<typeof DeploymentStatusSchema>;
+export type DeploymentBuildStatus = z.infer<typeof DeploymentBuildStatusSchema>;
+export type DeploymentReleaseStatus = z.infer<typeof DeploymentReleaseStatusSchema>;
+export type DeploymentSize = z.infer<typeof DeploymentSizeSchema>;
+export type DeploymentRegion = z.infer<typeof DeploymentRegionSchema>;
+export type DeploymentJurisdiction = z.infer<typeof DeploymentJurisdictionSchema>;
+export type DeploymentDomainDnsRecordType = z.infer<typeof DeploymentDomainDnsRecordTypeSchema>;
+export type DeploymentProtectionMode = z.infer<typeof DeploymentProtectionModeSchema>;
+export type DeploymentLogStream = z.infer<typeof DeploymentLogStreamSchema>;
+export type DeploymentEventData = z.infer<typeof DeploymentEventDataSchema>;
+export type DeploymentLogChunkData = z.infer<typeof DeploymentLogChunkDataSchema>;
+export type DeployStreamPhase = z.infer<typeof DeployStreamPhaseSchema>;
+export type DeployStreamLog = z.infer<typeof DeployStreamLogSchema>;
+export type DeployStreamResult = z.infer<typeof DeployStreamResultSchema>;
+export type DeployStreamEvent = z.infer<typeof DeployStreamEventSchema>;
+export type DeployStreamSseEvent = z.infer<typeof DeployStreamSseEventSchema>;

package/dist/schemas/deployments.js

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+export const DeploymentTargetProviderSchema = z.enum([
+    'okraCloudflareContainer',
+    'okraSshAgent',
+    'okraLaravelCloud',
+]);
+export const DeploymentStatusSchema = z.enum([
+    'pending',
+    'queued',
+    'building',
+    'deploying',
+    'healthy',
+    'failed',
+    'stopped',
+    'deleting',
+    'deleted',
+    'delete_failed',
+]);
+export const DeploymentBuildStatusSchema = z.enum([
+    'pending',
+    'queued',
+    'running',
+    'succeeded',
+    'failed',
+    'cancelled',
+]);
+export const DeploymentReleaseStatusSchema = z.enum(['created', 'ready', 'deleted']);
+export const DeploymentSizeSchema = z.enum([
+    'nano',
+    'small',
+    'medium',
+    'large',
+    'lite',
+    'basic',
+    'standard-1',
+    'standard-2',
+]);
+export const DeploymentRegionSchema = z.enum([
+    'ENAM',
+    'WNAM',
+    'EEUR',
+    'WEUR',
+    'APAC',
+    'SAM',
+    'ME',
+    'OC',
+    'AFR',
+]);
+export const DeploymentJurisdictionSchema = z.enum(['eu', 'fedramp']);
+export const DeploymentDomainDnsRecordTypeSchema = z.enum(['CNAME', 'ALIAS', 'ANAME']);
+export const DeploymentProtectionModeSchema = z.enum(['none', 'password']);
+export const DeploymentLogStreamSchema = z.enum(['build', 'runtime']);
+export const DeployStreamLogStreamSchema = z.enum(['build', 'deploy', 'runtime']);
+export const DeploymentEventDataSchema = z.object({
+    id: z.union([z.number(), z.string()]).optional(),
+    sequence: z.number(),
+    type: z.string(),
+    payload: z.record(z.string(), z.unknown()),
+    createdAt: z.string().nullable(),
+}).passthrough();
+export const DeploymentLogChunkDataSchema = z.object({
+    sequence: z.number(),
+    stream: DeploymentLogStreamSchema,
+    content: z.string(),
+    createdAt: z.string().nullable(),
+}).passthrough();
+export const DeployStreamPhaseSchema = z.object({
+    name: z.string(),
+    status: z.enum(['running', 'completed', 'failed']).optional(),
+    data: z.record(z.string(), z.unknown()).optional(),
+}).strict();
+export const DeployStreamLogSchema = z.object({
+    stream: DeployStreamLogStreamSchema,
+    content: z.string(),
+}).strict();
+export const DeployStreamResultSchema = z.object({
+    success: z.boolean(),
+    deploymentId: z.string(),
+    buildId: z.string(),
+    releaseId: z.string(),
+    status: DeploymentStatusSchema,
+}).strict();
+export const DeployStreamPhaseEventSchema = DeployStreamPhaseSchema.extend({
+    type: z.literal('phase'),
+}).strict();
+export const DeployStreamLogEventSchema = DeployStreamLogSchema.extend({
+    type: z.literal('log'),
+}).strict();
+export const DeployStreamResultEventSchema = DeployStreamResultSchema.extend({
+    type: z.literal('result'),
+}).strict();
+export const DeployStreamEventSchema = z.discriminatedUnion('type', [
+    DeployStreamPhaseEventSchema,
+    DeployStreamLogEventSchema,
+    DeployStreamResultEventSchema,
+]);
+export const DeployStreamErrorSchema = z.object({
+    message: z.string().optional(),
+}).passthrough();
+export const DeployStreamSseEventNameSchema = z.enum(['phase', 'log', 'done', 'result', 'error']);
+export const DeployStreamSsePhaseEventSchema = z.object({
+    event: z.literal('phase'),
+    data: DeployStreamPhaseSchema,
+}).strict();
+export const DeployStreamSseLogEventSchema = z.object({
+    event: z.literal('log'),
+    data: DeployStreamLogSchema,
+}).strict();
+export const DeployStreamSseDoneEventSchema = z.object({
+    event: z.literal('done'),
+    data: DeployStreamResultSchema,
+}).strict();
+export const DeployStreamSseResultEventSchema = z.object({
+    event: z.literal('result'),
+    data: DeployStreamResultSchema,
+}).strict();
+export const DeployStreamSseErrorEventSchema = z.object({
+    event: z.literal('error'),
+    data: DeployStreamErrorSchema,
+}).strict();
+export const DeployStreamSseEventSchema = z.discriminatedUnion('event', [
+    DeployStreamSsePhaseEventSchema,
+    DeployStreamSseLogEventSchema,
+    DeployStreamSseDoneEventSchema,
+    DeployStreamSseResultEventSchema,
+    DeployStreamSseErrorEventSchema,
+]).transform((event) => {
+    if (event.event === 'error') {
+        throw new Error(event.data.message ?? 'Deploy failed');
+    }
+    const type = event.event === 'done' ? 'result' : event.event;
+    return DeployStreamEventSchema.parse({ type, ...event.data });
+});