@phpsandbox/sdk 0.0.68 → 0.1.2

package/dist/index.d.ts

@@ -1,36 +1,38 @@
 import { Filesystem, FilesystemActions, FilesystemEvents } from './filesystem.js';
-import Terminal, { TerminalEvents, TerminalActions } from './terminal.js';
-import Container, { ContainerActions, ContainerEvents, PortInfo, TelemetryFeature } from './container.js';
+import Terminals, { TerminalEvents, TerminalActions, type SpawnOptions } from './terminal.js';
+import Container, { ContainerActions, ContainerEvents, PortInfo } from './container.js';
 import Auth, { AuthActions } from './auth.js';
 import Lsp, { LspActions, LspEvents } from './lsp.js';
 import Composer, { ComposerActions, ComposerEvents } from './composer.js';
-import Log, { LogActions, LogEvents } from './log.js';
-import Laravel, { LaravelActions, LaravelEvents } from './laravel.js';
+import Logs, { LogActions, LogEvents } from './log.js';
+import Metrics from './metrics.js';
+import Ports from './ports.js';
 import Repl, { ReplActions, ReplEvents } from './repl.js';
-import Shell, { ShellEvents, ShellActions } from './shell.js';
+import { ShellEvents, ShellActions, type ProcessResult, type ShellProcess } from './shell.js';
 import Services, { ServiceActions, ServiceEvents } from './services.js';
 import Config, { ConfigActions } from './config.js';
 import { EventDispatcher } from './events/index.js';
 import Git, { GitActions, GitCredentials, GitEvents } from './git.js';
 import { Disposable } from './types.js';
-import { Beacon, BeaconOptions } from './beacon/index.js';
 import { NotebookUnavailableError } from './errors/index.js';
-import { DeploymentApi, NotebookDeploymentApi, type DeploymentInstance, type DeploymentRun, type PublishInput } from './deployments.js';
+import { PublicationApi, NotebookPublicationApi, type PublicationInstance, type PublicationRun, type PublishInput } from './publications.js';
 import { ServerApi } from './servers.js';
 export * from './types.js';
-export { Transport } from './socket/index.js';
 export * from './lsp.js';
 export * from './filesystem.js';
 export * from './container.js';
+export * from './log.js';
+export * from './metrics.js';
+export * from './ports.js';
+export * from './runtime-telemetry.js';
 export * from './shell.js';
 export * from './terminal.js';
 export * from './git.js';
 export * from './services.js';
 export * from './config.js';
 export * from './utils/promise.js';
-export * from './beacon/index.js';
 export * from './errors/index.js';
-export * from './deployments.js';
+export * from './publications.js';
 export * from './servers.js';
 interface Result<TType extends 'success' | 'error' | 'running', TData extends object> {
     type: TType;
@@ -100,11 +102,11 @@ export interface Action<Args = object, Response = void> {
     args: Args;
     response: Response;
 }
-export type Events = TerminalEvents & ContainerEvents & LspEvents & ComposerEvents & LogEvents & ServiceEvents & LaravelEvents & NotebookEvents & ReplEvents & ShellEvents & FilesystemEvents & GitEvents;
+export type Events = TerminalEvents & ContainerEvents & LspEvents & ComposerEvents & LogEvents & ServiceEvents & NotebookEvents & ReplEvents & ShellEvents & FilesystemEvents & GitEvents;
 interface SystemActions {
     ping: Action<object, 'pong'>;
 }
-export type Invokable = SystemActions & TerminalActions & ContainerActions & FilesystemActions & AuthActions & LspActions & LaravelActions & ComposerActions & LogActions & ServiceActions & ConfigActions & NotebookActions & ReplActions & ShellActions & GitActions;
+export type Invokable = SystemActions & TerminalActions & ContainerActions & FilesystemActions & AuthActions & LspActions & ComposerActions & LogActions & ServiceActions & ConfigActions & NotebookActions & ReplActions & ShellActions & GitActions;
 export interface CreateNotebookImportAuthInput {
     access_token: string;
 }
@@ -289,22 +291,20 @@ export declare class NotebookApi {
     readonly composerCredentials: NotebookComposerCredentialApi;
     readonly preview: NotebookPreviewApi;
     readonly mail: NotebookMailApi;
-    readonly deployment: NotebookDeploymentApi;
+    readonly publication: NotebookPublicationApi;
     constructor(client: Client);
     create(template: string, input?: Partial<CreateNotebookInput>, init?: boolean): Promise<NotebookInstance>;
     get(id: string): Promise<NotebookInstance>;
     update(id: string, input?: Partial<UpdateNotebookInput>): Promise<NotebookInstance>;
-    delete(id: string): Promise<void>;
+    destroy(id: string): Promise<void>;
     fork(id: string, input?: Partial<ForkNotebookInput>): Promise<NotebookInstance>;
     gitCredentials(id: string): Promise<GitCredentials>;
-    open(id: string): Promise<NotebookInstance>;
     openFromData(data: NotebookData): Promise<NotebookInstance>;
     private init;
 }
 export interface PHPSandboxClientOptions {
     debug?: boolean;
     startClosed?: boolean;
-    telemetry?: Set<TelemetryFeature>;
     fetch?: typeof globalThis.fetch;
     webSocket?: unknown;
     runtimeUrlProvider?: (notebookId: string) => Promise<string>;
@@ -312,7 +312,7 @@ export interface PHPSandboxClientOptions {
 export type RuntimeTransport = 'realtime' | 'rest';
 export declare class Client {
     readonly notebook: NotebookApi;
-    readonly deployments: DeploymentApi;
+    readonly publications: PublicationApi;
     readonly servers: ServerApi;
     readonly options: PHPSandboxClientOptions;
     protected runtimeTransportValue: RuntimeTransport;
@@ -389,16 +389,17 @@ export declare class NotebookInstance {
     #private;
     readonly data: NotebookData;
     protected client: Client;
-    readonly file: Filesystem;
-    readonly terminal: Terminal;
+    readonly files: Filesystem;
+    readonly terminals: Terminals;
     readonly auth: Auth;
     readonly lsp: Lsp;
     readonly composer: Composer;
-    readonly log: Log;
+    readonly logs: Logs;
+    readonly metrics: Metrics;
+    readonly ports: Ports;
     readonly repl: Repl;
     readonly container: Container;
-    readonly laravel: Laravel;
-    readonly shell: Shell;
+    private readonly shell;
     readonly git: Git;
     readonly services: Services;
     readonly config: Config;
@@ -414,10 +415,14 @@ export declare class NotebookInstance {
     constructor(data: NotebookData, client: Client);
     ready(): Promise<NotebookInitSuccessResult>;
     fork(input?: Partial<ForkNotebookInput>): Promise<NotebookInstance>;
-    deployment(): Promise<DeploymentInstance | null>;
-    publish(input?: PublishInput): Promise<DeploymentRun>;
+    publication(): Promise<PublicationInstance | null>;
+    publish(input: PublishInput): Promise<PublicationRun>;
+    run(command: string | string[], opts?: SpawnOptions): ShellProcess;
+    run(command: string, args: string[], opts?: SpawnOptions): ShellProcess;
+    exec(command: string | string[], opts?: SpawnOptions): Promise<ProcessResult>;
+    exec(command: string, args: string[], opts?: SpawnOptions): Promise<ProcessResult>;
     gitCredentials(): Promise<GitCredentials>;
-    delete(): Promise<void>;
+    destroy(): Promise<void>;
     stop(): Promise<void>;
     restart(): Promise<void>;
     invoke<T extends keyof Invokable>(action: T, data?: Invokable[T]['args'], options?: CallOption): Promise<Invokable[T]['response']>;
@@ -437,7 +442,6 @@ export declare class NotebookInstance {
     update(input: Partial<UpdateNotebookInput>): Promise<NotebookInstance>;
     onDidInitialize(handler: (result: NotebookInitResult) => void): Disposable;
     reconnect(): Promise<NotebookInstance>;
-    beacon(iframe: HTMLIFrameElement, options?: BeaconOptions): Promise<Beacon>;
     private realtimeSocket;
 }
 export declare class NotebookSecrets {

package/dist/index.js

@@ -11,13 +11,15 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 };
 var _NotebookInstance_instances, _NotebookInstance_initPromise, _NotebookInstance_init;
 import { Filesystem } from './filesystem.js';
-import Terminal from './terminal.js';
+import Terminals from './terminal.js';
 import Container from './container.js';
 import Auth from './auth.js';
 import Lsp from './lsp.js';
 import Composer from './composer.js';
-import Log from './log.js';
-import Laravel from './laravel.js';
+import Logs from './log.js';
+import Metrics from './metrics.js';
+import Ports from './ports.js';
+import { RuntimeTelemetry } from './runtime-telemetry.js';
 import Repl from './repl.js';
 import Shell from './shell.js';
 import Services from './services.js';
@@ -25,25 +27,26 @@ import Config from './config.js';
 import { Transport } from './socket/index.js';
 import EventManager from './events/index.js';
 import Git from './git.js';
-import { createBeacon } from './beacon/index.js';
 import { NotebookUnavailableError, UnsupportedRuntimeTransportError } from './errors/index.js';
-import { DeploymentApi, NotebookDeploymentApi } from './deployments.js';
+import { PublicationApi, NotebookPublicationApi } from './publications.js';
 import { ServerApi } from './servers.js';
 import { RestRuntimeInvoker } from './runtime/rest.js';
 export * from './types.js';
-export { Transport } from './socket/index.js';
 export * from './lsp.js';
 export * from './filesystem.js';
 export * from './container.js';
+export * from './log.js';
+export * from './metrics.js';
+export * from './ports.js';
+export * from './runtime-telemetry.js';
 export * from './shell.js';
 export * from './terminal.js';
 export * from './git.js';
 export * from './services.js';
 export * from './config.js';
 export * from './utils/promise.js';
-export * from './beacon/index.js';
 export * from './errors/index.js';
-export * from './deployments.js';
+export * from './publications.js';
 export * from './servers.js';
 function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
@@ -101,7 +104,7 @@ export class NotebookApi {
         this.composerCredentials = new NotebookComposerCredentialApi(client);
         this.preview = new NotebookPreviewApi(client);
         this.mail = new NotebookMailApi(client);
-        this.deployment = new NotebookDeploymentApi(client);
+        this.publication = new NotebookPublicationApi(client);
     }
     async create(template, input = {}, init = true) {
         const response = await this.client.post('/notebook', { template, ...input });
@@ -119,7 +122,7 @@ export class NotebookApi {
         const response = await this.client.put(`/notebook/${id}`, input);
         return new NotebookInstance(response.data, this.client);
     }
-    async delete(id) {
+    async destroy(id) {
         await this.client.delete(`/notebook/${id}`);
     }
     async fork(id, input = {}) {
@@ -130,10 +133,6 @@ export class NotebookApi {
         const response = await this.client.post(`/notebook/${id}/git/credentials`);
         return response.data;
     }
-    async open(id) {
-        const response = await this.client.get(`/notebook/${id}`);
-        return new NotebookInstance(response.data, this.client);
-    }
     openFromData(data) {
         return this.init(new NotebookInstance(data, this.client));
     }
@@ -157,7 +156,7 @@ export class Client {
     constructor(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
         this.runtimeTransportValue = 'realtime';
         this.fetch = globalThis.fetch;
-        this.deployments = new DeploymentApi(this);
+        this.publications = new PublicationApi(this);
         this.notebook = new NotebookApi(this);
         this.servers = new ServerApi(this);
         this.options = Object.assign({ startClosed: true }, options);
@@ -375,15 +374,17 @@ export class NotebookInstance {
             this.watchConnection();
             __classPrivateFieldSet(this, _NotebookInstance_initPromise, __classPrivateFieldGet(this, _NotebookInstance_instances, "m", _NotebookInstance_init).call(this), "f");
         }
-        this.file = new Filesystem(this, this.socket === null ? null : (handler) => this.onDidConnect(handler));
-        this.terminal = new Terminal(this);
+        this.files = new Filesystem(this, this.socket === null ? null : (handler) => this.onDidConnect(handler));
+        this.terminals = new Terminals(this);
         this.auth = new Auth(this);
         this.lsp = new Lsp(this);
         this.composer = new Composer(this, client);
-        this.log = new Log(this);
+        const telemetry = new RuntimeTelemetry(this);
+        this.logs = new Logs(this, telemetry);
+        this.metrics = new Metrics(this, telemetry);
+        this.ports = new Ports(this, telemetry);
         this.repl = new Repl(this);
         this.container = new Container(this);
-        this.laravel = new Laravel(this);
         this.shell = new Shell(this);
         this.git = new Git(this, client);
         this.services = new Services(this);
@@ -418,17 +419,29 @@ export class NotebookInstance {
     fork(input = {}) {
         return this.client.notebook.fork(this.data.id, input);
     }
-    deployment() {
-        return this.client.notebook.deployment.current(this.data.id);
+    publication() {
+        return this.client.notebook.publication.current(this.data.id);
     }
     publish(input) {
-        return this.client.notebook.deployment.publish(this.data.id, input);
+        return this.client.notebook.publication.publish(this.data.id, input);
+    }
+    run(command, argsOrOpts = [], opts) {
+        if (Array.isArray(argsOrOpts)) {
+            return this.shell.run(command, argsOrOpts, opts);
+        }
+        return this.shell.run(command, argsOrOpts);
+    }
+    exec(command, argsOrOpts = [], opts) {
+        if (Array.isArray(argsOrOpts)) {
+            return this.run(command, argsOrOpts, opts).wait();
+        }
+        return this.run(command, argsOrOpts).wait();
     }
     gitCredentials() {
         return this.client.notebook.gitCredentials(this.data.id);
     }
-    delete() {
-        return this.client.notebook.delete(this.data.id).then(() => {
+    destroy() {
+        return this.client.notebook.destroy(this.data.id).then(() => {
             this.socket?.terminate(new NotebookUnavailableError('Notebook has been deleted.', { id: this.data.id }));
         });
     }
@@ -515,9 +528,6 @@ export class NotebookInstance {
         const socket = this.realtimeSocket();
         socket.onDidConnect(() => {
             socket.emit('okra.connected');
-            if (this.client.options.telemetry) {
-                this.container.enableTelemetry(this.client.options.telemetry);
-            }
         });
         socket.onDidClose(() => {
             socket.emit('okra.disconnected');
@@ -581,11 +591,6 @@ export class NotebookInstance {
         // Wait for initialization to complete
         return this.ready().then(() => this);
     }
-    async beacon(iframe, options) {
-        const result = await this.ready();
-        iframe.src = result.data.previewUrl;
-        return createBeacon(iframe, options);
-    }
     realtimeSocket() {
         if (this.socket === null) {
             throw new UnsupportedRuntimeTransportError('This operation requires the realtime transport.');

package/dist/log.d.ts

@@ -1,12 +1,18 @@
-import { Disposable, NotebookInstance } from './index.js';
+import type { NotebookInstance } from './index.js';
+import { RuntimeTelemetry, type RuntimeWatchOptions } from './runtime-telemetry.js';
 export interface LogEvents {
     'notebook.log': string;
 }
 export interface LogActions {
 }
-export default class Log {
+export interface RuntimeLogEntry {
+    timestamp: string;
+    source: 'runtime';
+    message: string;
+}
+export default class Logs {
     protected okra: NotebookInstance;
-    constructor(okra: NotebookInstance);
-    stream(fn: (data: string) => void): Disposable;
-    listen<T extends keyof LogEvents>(event: T, handler: (data: LogEvents[T]) => void): Disposable;
+    private readonly telemetry;
+    constructor(okra: NotebookInstance, telemetry: RuntimeTelemetry);
+    follow(options?: RuntimeWatchOptions): ReadableStream<RuntimeLogEntry>;
 }

package/dist/log.js

@@ -1,11 +1,14 @@
-export default class Log {
-    constructor(okra) {
+import { watchRuntimeTelemetry } from './runtime-telemetry.js';
+export default class Logs {
+    constructor(okra, telemetry) {
         this.okra = okra;
+        this.telemetry = telemetry;
     }
-    stream(fn) {
-        return this.okra.listen('notebook.log', fn);
-    }
-    listen(event, handler) {
-        return this.okra.listen(event, handler);
+    follow(options = {}) {
+        return watchRuntimeTelemetry(this.okra, this.telemetry, 'logs', 'notebook.log', (message) => ({
+            timestamp: new Date().toISOString(),
+            source: 'runtime',
+            message,
+        }), options);
     }
 }

package/dist/metrics.d.ts

@@ -0,0 +1,10 @@
+import type { NotebookInstance } from './index.js';
+import type { ContainerStats } from './container.js';
+import { RuntimeTelemetry, type RuntimeWatchOptions } from './runtime-telemetry.js';
+export default class Metrics {
+    private readonly okra;
+    private readonly telemetry;
+    constructor(okra: NotebookInstance, telemetry: RuntimeTelemetry);
+    current(): Promise<ContainerStats | null>;
+    watch(options?: RuntimeWatchOptions): ReadableStream<ContainerStats>;
+}

package/dist/metrics.js

@@ -0,0 +1,13 @@
+import { watchRuntimeTelemetry } from './runtime-telemetry.js';
+export default class Metrics {
+    constructor(okra, telemetry) {
+        this.okra = okra;
+        this.telemetry = telemetry;
+    }
+    current() {
+        return this.okra.invoke('container.stats');
+    }
+    watch(options = {}) {
+        return watchRuntimeTelemetry(this.okra, this.telemetry, 'stats', 'container.stats', (stats) => stats, options);
+    }
+}

package/dist/ports.d.ts

@@ -0,0 +1,10 @@
+import type { NotebookInstance } from './index.js';
+import type { PortInfo } from './container.js';
+import { RuntimeTelemetry, type RuntimeWatchOptions } from './runtime-telemetry.js';
+export default class Ports {
+    private readonly okra;
+    private readonly telemetry;
+    constructor(okra: NotebookInstance, telemetry: RuntimeTelemetry);
+    list(): Promise<PortInfo[]>;
+    watch(options?: RuntimeWatchOptions): ReadableStream<PortInfo[]>;
+}

package/dist/ports.js

@@ -0,0 +1,13 @@
+import { watchRuntimeTelemetry } from './runtime-telemetry.js';
+export default class Ports {
+    constructor(okra, telemetry) {
+        this.okra = okra;
+        this.telemetry = telemetry;
+    }
+    list() {
+        return this.okra.invoke('container.opened-ports');
+    }
+    watch(options = {}) {
+        return watchRuntimeTelemetry(this.okra, this.telemetry, 'ports', 'container.ports', (ports) => ports, options);
+    }
+}

package/dist/publications.d.ts

@@ -0,0 +1,222 @@
+import { type Client, type SecretRef } from './index.js';
+import type { PublicationBuildStatus, PublicationDomainDnsRecordType, PublicationEventData, PublicationJurisdiction, PublicationLogChunkData, PublicationProtectionMode, PublicationRegion, PublicationReleaseStatus, PublicationSize, PublicationStatus, PublishStreamEvent, PublishStreamResult } from './schemas/publications.js';
+export * from './schemas/publications.js';
+export interface PublicationPlacement {
+    regions?: PublicationRegion[];
+    jurisdiction?: PublicationJurisdiction;
+}
+export type LaravelCloudRegion = 'us-east-2' | 'us-east-1' | 'ca-central-1' | 'eu-central-1' | 'eu-west-1' | 'eu-west-2' | 'me-central-1' | 'ap-southeast-1' | 'ap-southeast-2' | 'ap-northeast-1';
+export interface PublicationProtectionData {
+    mode: PublicationProtectionMode;
+    enabled: boolean;
+    token?: string;
+    expiresAt?: string;
+    url?: string;
+}
+export interface PublicationFeedbackData {
+    enabled: boolean;
+    config: Record<string, unknown>;
+}
+export type PublicationProtectionInput = {
+    mode: 'none';
+    password?: never;
+} | {
+    mode: 'password';
+    password: string;
+};
+export interface PublicationFeedbackInput {
+    enabled: boolean;
+    config?: Record<string, unknown>;
+}
+export interface CloudflareContainersProviderOptions {
+    size?: PublicationSize;
+    sleepAfter?: string;
+    placement?: PublicationPlacement;
+    instances?: number;
+}
+export interface SshServerProviderOptions {
+    serverId: string;
+}
+export interface LaravelCloudProviderData {
+    region?: LaravelCloudRegion;
+    repository?: string;
+    branch?: string;
+    sourceControlProviderType?: 'github' | 'gitlab' | 'bitbucket';
+    apiKeyConfigured?: boolean;
+}
+export interface LaravelCloudProviderInput {
+    apiKey: SecretRef;
+    region?: LaravelCloudRegion;
+}
+export interface PublicationProviderInputs {
+    'cloudflare-containers': CloudflareContainersProviderOptions;
+    'ssh-server': SshServerProviderOptions;
+    'laravel-cloud': LaravelCloudProviderInput;
+}
+export interface PublicationProviderData {
+    'cloudflare-containers': CloudflareContainersProviderOptions;
+    'ssh-server': SshServerProviderOptions;
+    'laravel-cloud': LaravelCloudProviderData;
+}
+export type PublicationProviderName = Extract<keyof PublicationProviderInputs, string>;
+export type PublicationProviderInput<TName extends PublicationProviderName = PublicationProviderName> = {
+    [Name in TName]: {
+        name: Name;
+    } & PublicationProviderInputs[Name];
+}[TName];
+export type PublicationProvider<TName extends PublicationProviderName = PublicationProviderName> = {
+    [Name in TName]: {
+        name: Name;
+    } & PublicationProviderData[Name];
+}[TName];
+export interface PublishInput<TName extends PublicationProviderName = PublicationProviderName> {
+    slug: string;
+    provider: PublicationProviderInput<TName>;
+    protection?: PublicationProtectionInput;
+    feedback?: PublicationFeedbackInput;
+    metadata?: Record<string, unknown>;
+}
+export interface PublicationBuildData<TProvider extends PublicationProviderName = PublicationProviderName> {
+    id: string;
+    status: PublicationBuildStatus;
+    strategy: string;
+    provider: PublicationProvider<TProvider>;
+    errorMessage: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+export interface PublicationReleaseData {
+    id: string;
+    status: PublicationReleaseStatus;
+    manifest: Record<string, unknown>;
+}
+export interface PublicationDomainDnsData {
+    type: PublicationDomainDnsRecordType;
+    name: string;
+    value: string;
+}
+export interface PublicationDomainData {
+    id: string;
+    publicationId: string | null;
+    hostname: string;
+    status: string;
+    provider: string;
+    providerHostnameId: string | null;
+    dns: PublicationDomainDnsData;
+    ssl: {
+        status: string | null;
+    };
+    validationErrors: unknown[];
+    validationRecords: unknown[];
+    metadata: Record<string, unknown>;
+    verifiedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export interface CreatePublicationDomainInput {
+    hostname: string;
+}
+export interface PublicationData<TProvider extends PublicationProviderName = PublicationProviderName> {
+    id: string;
+    slug: string;
+    url: string;
+    status: PublicationStatus;
+    strategy: string;
+    provider: PublicationProvider<TProvider>;
+    protection: PublicationProtectionData;
+    feedback: PublicationFeedbackData;
+    eventStreamUrl: string | null;
+    originUrl: string | null;
+    currentRelease?: PublicationReleaseData | null;
+    domains?: PublicationDomainData[];
+    latestBuild?: PublicationBuildData<TProvider> | null;
+    deployedAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export interface UpdatePublicationProtectionInput {
+    mode: PublicationProtectionMode;
+    password?: string;
+}
+export interface PublicationProtectionSessionData {
+    previewSessionId: string;
+    token: string;
+    expiresAt: string;
+    url: string;
+}
+export interface UpdatePublicationFeedbackInput {
+    enabled: boolean;
+    config?: Record<string, unknown>;
+}
+export declare class NotebookPublicationApi {
+    private readonly client;
+    constructor(client: Client);
+    current<TProvider extends PublicationProviderName = PublicationProviderName>(notebookId: string): Promise<PublicationInstance<TProvider> | null>;
+    publish<TProvider extends PublicationProviderName = PublicationProviderName>(notebookId: string, input?: PublishInput): Promise<PublicationRun<TProvider>>;
+}
+export declare class PublicationApi {
+    private readonly client;
+    constructor(client: Client);
+    get<TProvider extends PublicationProviderName = PublicationProviderName>(id: string): Promise<PublicationInstance<TProvider>>;
+    destroy(id: string): Promise<void>;
+    setProtection<TProvider extends PublicationProviderName = PublicationProviderName>(id: string, input: UpdatePublicationProtectionInput): Promise<PublicationInstance<TProvider>>;
+    protection(id: string): Promise<PublicationProtectionData>;
+    createProtectionSession(id: string): Promise<PublicationProtectionSessionData>;
+    disableProtection<TProvider extends PublicationProviderName = PublicationProviderName>(id: string): Promise<PublicationInstance<TProvider>>;
+    setFeedback<TProvider extends PublicationProviderName = PublicationProviderName>(id: string, input: UpdatePublicationFeedbackInput): Promise<PublicationInstance<TProvider>>;
+    listDomains(id: string): Promise<PublicationDomainData[]>;
+    createDomain(id: string, input: CreatePublicationDomainInput): Promise<PublicationDomainData>;
+    refreshDomain(id: string, domainId: string): Promise<PublicationDomainData>;
+    deleteDomain(id: string, domainId: string): Promise<void>;
+    events(id: string): Promise<ReadableStream<PublicationEventData>>;
+    buildLogs(id: string, buildId: string): Promise<ReadableStream<PublicationLogChunkData>>;
+    logs(id: string): Promise<ReadableStream<PublicationLogChunkData>>;
+}
+export declare class PublicationRun<TProvider extends PublicationProviderName = PublicationProviderName> {
+    readonly initial: PublicationInstance<TProvider>;
+    private readonly client;
+    private started;
+    private completed;
+    private finalError;
+    private finalResult;
+    private resultPromise;
+    private resolveResult;
+    private rejectResult;
+    private readonly bufferedEvents;
+    private readonly subscribers;
+    constructor(initial: PublicationInstance<TProvider>, client: Client);
+    events(): AsyncIterable<PublishStreamEvent>;
+    result(): Promise<PublishStreamResult>;
+    publication(): Promise<PublicationInstance<TProvider>>;
+    start(): this;
+    private subscribe;
+    private consumeStream;
+    private publish;
+    private closeSubscribers;
+    private fail;
+}
+export declare class PublicationInstance<TProvider extends PublicationProviderName = PublicationProviderName> {
+    readonly data: PublicationData<TProvider>;
+    private readonly client;
+    private readonly notebookId?;
+    constructor(data: PublicationData<TProvider>, client: Client, notebookId?: string);
+    refresh(): Promise<PublicationInstance<TProvider>>;
+    publish(): Promise<PublicationRun<TProvider>>;
+    destroy(): Promise<void>;
+    wait(options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<PublicationInstance<TProvider>>;
+    events(): Promise<ReadableStream<PublicationEventData>>;
+    buildLogs(buildId?: string): Promise<ReadableStream<PublicationLogChunkData>>;
+    logs(): Promise<ReadableStream<PublicationLogChunkData>>;
+    setProtection(input: UpdatePublicationProtectionInput): Promise<PublicationInstance<TProvider>>;
+    protection(): Promise<PublicationProtectionData>;
+    createProtectionSession(): Promise<PublicationProtectionSessionData>;
+    disableProtection(): Promise<PublicationInstance<TProvider>>;
+    setFeedback(input: UpdatePublicationFeedbackInput): Promise<PublicationInstance<TProvider>>;
+    domains(): Promise<PublicationDomainData[]>;
+    addDomain(input: CreatePublicationDomainInput): Promise<PublicationDomainData>;
+    refreshDomain(domainId: string): Promise<PublicationDomainData>;
+    deleteDomain(domainId: string): Promise<void>;
+}