@phpsandbox/sdk 0.1.9 → 0.1.10

package/dist/index.js

@@ -12,14 +12,10 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _NotebookInstance_instances, _NotebookInstance_initPromise, _NotebookInstance_init;
 import { Filesystem } from './filesystem.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 Logs from './log.js';
-import Metrics from './metrics.js';
-import Ports from './ports.js';
-import { RuntimeTelemetry } from './runtime-telemetry.js';
+import Runtime from './runtime.js';
 import Repl from './repl.js';
 import Shell from './shell.js';
 import Services from './services.js';
@@ -27,33 +23,17 @@ import Config from './config.js';
 import { Transport } from './socket/index.js';
 import EventManager from './events/index.js';
 import Git from './git.js';
-import { NotebookUnavailableError, UnsupportedRuntimeTransportError } from './errors/index.js';
-import { PublicationApi, NotebookPublicationApi } from './publications.js';
+import { PHPSandboxError, RemoteError, TransportError, remoteError, } from './errors/index.js';
+import { PublicationApi, PublicationInstance, PublicationRun, } from './publications.js';
 import { ServerApi } from './servers.js';
 import { RestRuntimeInvoker } from './runtime/rest.js';
 import { Feedback } from './feedback.js';
 import { IntegrationApi } from './integrations.js';
 import { SandboxIntegrationApi } from './sandbox-integrations.js';
-export * from './types.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 './errors/index.js';
-export * from './publications.js';
-export * from './servers.js';
-export * from './feedback.js';
-export * from './integrations.js';
-export * from './sandbox-integrations.js';
+export { LspConnection } from './lsp.js';
+export { FileChangeFilter, FileChangeType, FileType, } from './filesystem.js';
+export { notebookBuiltinServices, notebookKnownServices } from './services.js';
+export { PHPSandboxError, RemoteError, TransportError, } from './errors/index.js';
 function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
         return input;
@@ -63,88 +43,20 @@ function normalizeNotebookSecretInputs(input) {
         ...(typeof value === 'string' ? { value } : value),
     }));
 }
-export class NotebookInitError extends Error {
-    constructor(message, data = {}) {
-        super(message);
-        this.message = message;
-        this.data = data;
-        this.name = 'NotebookInitError';
-    }
-}
-export class ApiError extends Error {
-    constructor(response, body) {
-        const data = parseApiErrorBody(body);
-        const apiMessage = apiErrorMessage(data, body);
-        super(`PHPSandbox API Error: ${response.status} ${response.statusText}${apiMessage === '' ? '' : ` - ${apiMessage}`}`);
-        this.response = response;
-        this.body = body;
-        this.status = response.status;
-        this.data = data;
-        this.apiMessage = apiMessage === '' ? undefined : apiMessage;
-    }
-}
-function parseApiErrorBody(body) {
-    try {
-        return JSON.parse(body);
-    }
-    catch {
-        return null;
-    }
-}
-function apiErrorMessage(data, fallback) {
-    if (data !== null && typeof data === 'object') {
-        const record = data;
-        if (typeof record.message === 'string' && record.message.trim() !== '') {
-            return record.message.trim();
-        }
-        if (record.error !== undefined) {
-            return typeof record.error === 'string' ? record.error.trim() : JSON.stringify(record.error);
-        }
-    }
-    return fallback.trim();
-}
-export class NotebookApi {
+class NotebookApi {
     constructor(client) {
         this.client = client;
-        this.secrets = new NotebookSecretApi(client);
-        this.composerCredentials = new NotebookComposerCredentialApi(client);
-        this.preview = new NotebookPreviewApi(client);
-        this.mail = new NotebookMailApi(client);
-        this.publication = new NotebookPublicationApi(client);
     }
-    async create(template, input = {}, init = true) {
+    async create(template, input = {}) {
         const response = await this.client.post('/notebook', { template, ...input });
-        const instance = new NotebookInstance(response.data, this.client);
-        if (!init) {
-            return instance;
-        }
-        return this.init(instance);
+        return new NotebookInstance(response.data, this.client);
     }
     async get(id) {
         const response = await this.client.get(`/notebook/${id}`);
         return new NotebookInstance(response.data, this.client);
     }
-    async update(id, input = {}) {
-        const response = await this.client.put(`/notebook/${id}`, input);
-        return new NotebookInstance(response.data, this.client);
-    }
-    async destroy(id) {
-        await this.client.delete(`/notebook/${id}`);
-    }
-    async fork(id, input = {}) {
-        const response = await this.client.post(`/notebook/${id}/fork`, input);
-        return new NotebookInstance(response.data, this.client);
-    }
-    async gitCredentials(id) {
-        const response = await this.client.post(`/notebook/${id}/git/credentials`);
-        return response.data;
-    }
-    openFromData(data) {
-        return this.init(new NotebookInstance(data, this.client));
-    }
-    async init(instance) {
-        await instance.ready();
-        return instance;
+    open(data) {
+        return new NotebookInstance(data, this.client);
     }
 }
 function normalizeApiBaseUrl(url) {
@@ -155,18 +67,18 @@ function normalizeApiBaseUrl(url) {
     baseUrl.hash = '';
     return baseUrl.toString();
 }
-export class Client {
+class ClientImplementation {
     get runtimeTransport() {
         return this.runtimeTransportValue;
     }
-    constructor(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
-        this.runtimeTransportValue = 'realtime';
+    constructor(token, url = 'https://api.phpsandbox.io/v1', options = {}, runtimeTransport = 'realtime') {
         this.fetch = globalThis.fetch;
         this.publications = new PublicationApi(this);
         this.notebook = new NotebookApi(this);
         this.servers = new ServerApi(this);
         this.integrations = new IntegrationApi(this);
-        this.options = Object.assign({ startClosed: true }, options);
+        this.options = { ...options };
+        this.runtimeTransportValue = runtimeTransport;
         this.baseUrl = normalizeApiBaseUrl(url);
         if (options.fetch) {
             this.fetch = options.fetch;
@@ -193,156 +105,112 @@ export class Client {
         return this.makeRequest('PATCH', path, { body: body === undefined ? undefined : JSON.stringify(body) });
     }
     async stream(path) {
-        const response = await this.fetch(new Request(new URL(path.replace(/^\//, ''), this.baseUrl), {
+        const response = await this.fetchResponse(new Request(new URL(path.replace(/^\//, ''), this.baseUrl), {
             method: 'GET',
             headers: this.headers,
+            redirect: 'error',
         }));
         if (!response.ok) {
-            throw new ApiError(response, await response.text());
+            throw remoteError('core', errorPayload(await responsePayload(response)), response);
         }
         if (!response.body) {
-            throw new Error('PHPSandbox API Error: response body is not readable');
+            throw new TransportError('PHPSandbox API response body is not readable.', 'InvalidResponse', response);
         }
         return response.body;
     }
     async sse(url) {
-        const response = await this.fetch(new Request(url, {
+        const response = await this.fetchResponse(new Request(url, {
             method: 'GET',
+            redirect: 'error',
             headers: {
                 ...this.headers,
                 'Accept': 'text/event-stream',
             },
         }));
         if (!response.ok) {
-            throw new ApiError(response, await response.text());
+            throw remoteError('core', errorPayload(await responsePayload(response)), response);
         }
         if (!response.body) {
-            throw new Error('PHPSandbox API Error: SSE response body is not readable');
+            throw new TransportError('PHPSandbox API SSE response body is not readable.', 'InvalidResponse', response);
         }
         return response.body;
     }
     async makeRequest(method, path, init) {
-        const response = await this.fetch(new Request(new URL(path.replace(/^\//, ''), this.baseUrl), {
+        const response = await this.fetchResponse(new Request(new URL(path.replace(/^\//, ''), this.baseUrl), {
             method,
             ...init,
             headers: this.headers,
+            redirect: 'error',
         }));
         if (!response.ok) {
-            throw new ApiError(response, await response.text());
+            throw remoteError('core', errorPayload(await responsePayload(response)), response);
         }
         if (response.status === 204) {
             return { data: undefined };
         }
         const body = await response.text();
-        return { data: body === '' ? undefined : JSON.parse(body) };
-    }
-}
-export class PHPSandbox extends Client {
-    static realtime(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
-        return new PHPSandbox(token, url, options);
+        if (body === '') {
+            throw new TransportError('PHPSandbox API returned an empty response.', 'InvalidResponse', response);
+        }
+        try {
+            const payload = JSON.parse(body);
+            if (payload === null || typeof payload !== 'object' || Array.isArray(payload) || !Object.prototype.hasOwnProperty.call(payload, 'data')) {
+                throw new TransportError('PHPSandbox API returned an invalid success response.', 'InvalidResponse', response);
+            }
+            return payload;
+        }
+        catch (error) {
+            if (TransportError.is(error)) {
+                throw error;
+            }
+            throw new TransportError('PHPSandbox API returned an invalid JSON response.', 'InvalidResponse', error);
+        }
     }
-    static rest(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
-        const client = new PHPSandbox(token, url, options);
-        client.runtimeTransportValue = 'rest';
-        return client;
+    async fetchResponse(request) {
+        try {
+            return await this.fetch(request);
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw error;
+            }
+            throw new TransportError('Unable to reach the PHPSandbox API.', 'ConnectionFailed', error);
+        }
     }
 }
-export class NotebookSecretApi {
-    constructor(client) {
-        this.client = client;
-    }
-    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 function responsePayload(response) {
+    const body = await response.text();
+    if (body === '') {
+        return undefined;
     }
-    async set(id, name, input) {
-        const payload = typeof input === 'string' ? { name, value: input } : { name, ...input };
-        const response = await this.client.put(`/notebook/${id}/secrets`, payload);
-        return response.data;
-    }
-    async setMany(id, input) {
-        const response = await this.client.put(`/notebook/${id}/secrets`, {
-            secrets: normalizeNotebookSecretInputs(input),
-        });
-        return response.data;
+    try {
+        return JSON.parse(body);
     }
-    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}` : ''}`);
+    catch (error) {
+        throw new TransportError('PHPSandbox API returned an invalid JSON response.', 'InvalidResponse', error);
     }
 }
-export class NotebookComposerCredentialApi {
-    constructor(client) {
-        this.client = client;
-    }
-    async set(id, input) {
-        const response = await this.client.put(`/notebook/${id}/composer/credentials`, input);
-        return response.data;
-    }
-    async remove(id, type, url) {
-        const params = new URLSearchParams({ type });
-        if (url)
-            params.set('url', url);
-        await this.client.delete(`/notebook/${id}/composer/credentials?${params.toString()}`);
-    }
+function errorPayload(payload) {
+    return payload !== null && typeof payload === 'object' && !Array.isArray(payload)
+        ? payload.error
+        : undefined;
 }
-export class NotebookPreviewApi {
+export class PHPSandbox {
     constructor(client) {
         this.client = client;
+        this.notebook = client.notebook;
+        this.publications = client.publications;
+        this.servers = client.servers;
+        this.integrations = client.integrations;
     }
-    async get(id, url) {
-        const query = url === undefined ? '' : `?${new URLSearchParams({ url }).toString()}`;
-        const response = await this.client.get(`/notebook/${id}/preview${query}`);
-        return response.data;
-    }
-    async setPassword(id, input) {
-        const response = await this.client.put(`/notebook/${id}/preview`, input);
-        return response.data;
-    }
-    async disable(id) {
-        await this.client.delete(`/notebook/${id}/preview`);
-    }
-    async createSession(id, input) {
-        const response = await this.client.post(`/notebook/${id}/preview/session`, input);
-        return response.data;
-    }
-    async createHandoff(id, input) {
-        const response = await this.client.post(`/notebook/${id}/preview/handoff`, input);
-        return response.data;
-    }
-}
-export class NotebookMailApi {
-    constructor(client) {
-        this.client = client;
-    }
-    async status(id) {
-        const response = await this.client.get(`/notebook/${id}/mail`);
-        return response.data;
-    }
-    async enable(id) {
-        const response = await this.client.put(`/notebook/${id}/mail`);
-        return response.data;
-    }
-    async disable(id) {
-        await this.client.delete(`/notebook/${id}/mail`);
-    }
-    async list(id, options = {}) {
-        const response = await this.client.get(`/notebook/${id}/mails${formatQueryString(options)}`);
-        return response.data;
+    get runtimeTransport() {
+        return this.client.runtimeTransport;
     }
-    async get(id, hash) {
-        const response = await this.client.get(`/notebook/${id}/mails/${encodeURIComponent(hash)}`);
-        return response.data;
+    static realtime(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
+        return new PHPSandbox(new ClientImplementation(token, url, options));
     }
-    async delete(id, hash) {
-        await this.client.delete(`/notebook/${id}/mails/${encodeURIComponent(hash)}`);
+    static rest(token, url = 'https://api.phpsandbox.io/v1', options = {}) {
+        return new PHPSandbox(new ClientImplementation(token, url, options, 'rest'));
     }
 }
 export class NotebookInstance {
@@ -378,7 +246,6 @@ export class NotebookInstance {
                 };
             this.socket = new Transport(connectionUrl, this.emitter, {
                 debug: client.options.debug,
-                startClosed: client.options.startClosed,
                 webSocket: client.options.webSocket,
             });
             this.watchConnection();
@@ -389,12 +256,8 @@ export class NotebookInstance {
         this.auth = new Auth(this);
         this.lsp = new Lsp(this);
         this.composer = new Composer(this, client);
-        const telemetry = new RuntimeTelemetry(this);
-        this.logs = new Logs(this, telemetry);
-        this.metrics = new Metrics(this, telemetry);
-        this.ports = new Ports(this, telemetry);
+        this.runtime = new Runtime(this);
         this.repl = new Repl(this);
-        this.container = new Container(this);
         this.shell = new Shell(this);
         this.git = new Git(this, client);
         this.services = new Services(this);
@@ -419,7 +282,7 @@ export class NotebookInstance {
              * If ready is called, ensure the websocket is open so server-driven
              * initialization can begin, but do not block on an extra ping roundtrip.
              */
-            if (this.client.options.startClosed && !socket.isConnected) {
+            if (!socket.isConnected) {
                 await socket.connect();
             }
             return __classPrivateFieldGet(this, _NotebookInstance_initPromise, "f");
@@ -428,14 +291,27 @@ export class NotebookInstance {
         // Just apply a reasonable timeout for the entire initialization process
         return ready();
     }
-    fork(input = {}) {
-        return this.client.notebook.fork(this.data.id, input);
+    async fork(input = {}) {
+        const response = await this.client.post(`/notebook/${this.data.id}/fork`, input);
+        return new NotebookInstance(response.data, this.client);
     }
-    publication() {
-        return this.client.notebook.publication.current(this.data.id);
+    async publication() {
+        try {
+            const response = await this.client.get(`/notebook/${this.data.id}/publication`);
+            return new PublicationInstance(response.data, this.client, this.data.id);
+        }
+        catch (error) {
+            if (RemoteError.is(error) && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
     }
-    publish(input) {
-        return this.client.notebook.publication.publish(this.data.id, input);
+    async publish(input) {
+        const response = await this.client.post(`/notebook/${this.data.id}/publication`, input);
+        const run = new PublicationRun(new PublicationInstance(response.data, this.client, this.data.id), this.client);
+        run.start();
+        return run;
     }
     run(command, argsOrOpts = [], opts) {
         if (Array.isArray(argsOrOpts)) {
@@ -449,19 +325,20 @@ export class NotebookInstance {
         }
         return this.run(command, argsOrOpts).wait();
     }
-    gitCredentials() {
-        return this.client.notebook.gitCredentials(this.data.id);
+    async destroy() {
+        await this.client.delete(`/notebook/${this.data.id}`);
+        this.socket?.terminate(new RemoteError('Notebook has been deleted.', {
+            source: 'runtime',
+            status: 503,
+            code: 'NotebookUnavailable',
+            details: { id: this.data.id },
+        }));
     }
-    destroy() {
-        return this.client.notebook.destroy(this.data.id).then(() => {
-            this.socket?.terminate(new NotebookUnavailableError('Notebook has been deleted.', { id: this.data.id }));
-        });
+    restart() {
+        return this.invoke('container.restart');
     }
     stop() {
-        return this.container.stop();
-    }
-    restart() {
-        return this.container.restart();
+        return this.invoke('container.stop');
     }
     invoke(action, data = {}, options = {}) {
         if (this.restInvoker !== null) {
@@ -478,9 +355,6 @@ export class NotebookInstance {
         }
         return this.realtimeSocket().send(action, data || {});
     }
-    ping() {
-        return this.invoke('ping');
-    }
     listen(event, handler) {
         const disposable = this.emitter.listen(event, handler);
         this.disposables.push(disposable);
@@ -495,9 +369,6 @@ export class NotebookInstance {
     connected() {
         return this.waitForSocketConnection({ rejectOnClose: true });
     }
-    whenConnected() {
-        return this.waitForSocketConnection({ rejectOnClose: false });
-    }
     waitForSocketConnection(options) {
         const socket = this.realtimeSocket();
         const terminalError = socket.getTerminalError();
@@ -570,7 +441,7 @@ export class NotebookInstance {
     }
     restInitialization() {
         if (this.restInvoker === null) {
-            throw new UnsupportedRuntimeTransportError('This operation requires the REST transport.');
+            throw new PHPSandboxError('This operation requires the REST transport.');
         }
         if (__classPrivateFieldGet(this, _NotebookInstance_initPromise, "f") === null) {
             __classPrivateFieldSet(this, _NotebookInstance_initPromise, this.restInvoker.ready().then((result) => {
@@ -582,15 +453,12 @@ export class NotebookInstance {
         }
         return __classPrivateFieldGet(this, _NotebookInstance_initPromise, "f");
     }
-    update(input) {
-        return this.client.notebook.update(this.data.id, input);
-    }
     onDidInitialize(handler) {
         return this.listen('notebook.initialized', handler);
     }
     async reconnect() {
         const socket = this.realtimeSocket();
-        const whenConnected = this.whenConnected();
+        const whenConnected = this.waitForSocketConnection({ rejectOnClose: false });
         // Use the socket's reconnect method which preserves listeners
         // and uses the underlying ReconnectingWebSocket mechanism
         socket.reconnect();
@@ -605,7 +473,7 @@ export class NotebookInstance {
     }
     realtimeSocket() {
         if (this.socket === null) {
-            throw new UnsupportedRuntimeTransportError('This operation requires the realtime transport.');
+            throw new PHPSandboxError('This operation requires the realtime transport.');
         }
         return this.socket;
     }
@@ -617,7 +485,12 @@ _NotebookInstance_initPromise = new WeakMap(), _NotebookInstance_instances = new
             initializationListener.dispose();
             this.initialized = result;
             if (result.type === 'error') {
-                reject(new NotebookInitError(result.message, result.data));
+                reject(new RemoteError(result.message, {
+                    source: 'runtime',
+                    status: 503,
+                    code: 'NotebookInitializationFailed',
+                    details: result.data,
+                }));
                 return;
             }
             resolve(result);
@@ -635,79 +508,89 @@ _NotebookInstance_initPromise = new WeakMap(), _NotebookInstance_instances = new
     void __classPrivateFieldGet(this, _NotebookInstance_initPromise, "f").catch(() => { });
     return __classPrivateFieldGet(this, _NotebookInstance_initPromise, "f");
 };
-export class NotebookSecrets {
+class NotebookSecrets {
     constructor(client, notebookId) {
         this.client = client;
         this.notebookId = 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);
-    }
-    setMany(input) {
-        return this.client.notebook.secrets.setMany(this.notebookId, input);
-    }
-    delete(name, options) {
-        return this.client.notebook.secrets.delete(this.notebookId, name, options);
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options?.environment)
+            params.set('environment', options.environment);
+        const query = params.toString();
+        const response = await this.client.get(`/notebook/${this.notebookId}/secrets${query ? `?${query}` : ''}`);
+        return response.data;
     }
-}
-export class ComposerCredentials {
-    constructor(client, notebookId) {
-        this.client = client;
-        this.notebookId = notebookId;
+    async set(name, input) {
+        const payload = typeof input === 'string' ? { name, value: input } : { name, ...input };
+        const response = await this.client.put(`/notebook/${this.notebookId}/secrets`, payload);
+        return response.data;
     }
-    set(input) {
-        return this.client.notebook.composerCredentials.set(this.notebookId, input);
+    async setMany(input) {
+        const response = await this.client.put(`/notebook/${this.notebookId}/secrets`, {
+            secrets: normalizeNotebookSecretInputs(input),
+        });
+        return response.data;
     }
-    remove(type, url) {
-        return this.client.notebook.composerCredentials.remove(this.notebookId, type, url);
+    async delete(name, options) {
+        const params = new URLSearchParams();
+        if (options?.environment)
+            params.set('environment', options.environment);
+        const query = params.toString();
+        await this.client.delete(`/notebook/${this.notebookId}/secrets/${encodeURIComponent(name)}${query ? `?${query}` : ''}`);
     }
 }
-export class NotebookPreview {
+class NotebookPreview {
     constructor(client, notebookId) {
         this.client = client;
         this.notebookId = notebookId;
     }
-    get(url) {
-        return this.client.notebook.preview.get(this.notebookId, url);
+    async get(url) {
+        const query = url === undefined ? '' : `?${new URLSearchParams({ url }).toString()}`;
+        const response = await this.client.get(`/notebook/${this.notebookId}/preview${query}`);
+        return response.data;
     }
-    setPassword(input) {
-        return this.client.notebook.preview.setPassword(this.notebookId, input);
+    async setPassword(input) {
+        const response = await this.client.put(`/notebook/${this.notebookId}/preview`, input);
+        return response.data;
     }
-    disable() {
-        return this.client.notebook.preview.disable(this.notebookId);
+    async disable() {
+        await this.client.delete(`/notebook/${this.notebookId}/preview`);
     }
-    createSession(input) {
-        return this.client.notebook.preview.createSession(this.notebookId, input);
+    async createSession(input) {
+        const response = await this.client.post(`/notebook/${this.notebookId}/preview/session`, input);
+        return response.data;
     }
-    createHandoff(input) {
-        return this.client.notebook.preview.createHandoff(this.notebookId, input);
+    async createHandoff(input) {
+        const response = await this.client.post(`/notebook/${this.notebookId}/preview/handoff`, input);
+        return response.data;
     }
 }
-export class NotebookMail {
+class NotebookMail {
     constructor(client, notebookId) {
         this.client = client;
         this.notebookId = notebookId;
     }
-    status() {
-        return this.client.notebook.mail.status(this.notebookId);
+    async status() {
+        const response = await this.client.get(`/notebook/${this.notebookId}/mail`);
+        return response.data;
     }
-    enable() {
-        return this.client.notebook.mail.enable(this.notebookId);
+    async enable() {
+        const response = await this.client.put(`/notebook/${this.notebookId}/mail`);
+        return response.data;
     }
-    disable() {
-        return this.client.notebook.mail.disable(this.notebookId);
+    async disable() {
+        await this.client.delete(`/notebook/${this.notebookId}/mail`);
     }
-    list(options = {}) {
-        return this.client.notebook.mail.list(this.notebookId, options);
+    async list(options = {}) {
+        return this.client.get(`/notebook/${this.notebookId}/mails${formatQueryString(options)}`);
     }
-    get(hash) {
-        return this.client.notebook.mail.get(this.notebookId, hash);
+    async get(hash) {
+        const response = await this.client.get(`/notebook/${this.notebookId}/mails/${encodeURIComponent(hash)}`);
+        return response.data;
     }
-    delete(hash) {
-        return this.client.notebook.mail.delete(this.notebookId, hash);
+    async delete(hash) {
+        await this.client.delete(`/notebook/${this.notebookId}/mails/${encodeURIComponent(hash)}`);
     }
 }
 function formatQueryString(params) {