@phpsandbox/sdk 0.1.4 → 0.1.6

package/dist/feedback.d.ts

@@ -0,0 +1,73 @@
+import type { Client, PaginatedApiResponse } from './index.js';
+export type FeedbackType = 'bug' | 'suggestion' | 'question' | 'other';
+export type FeedbackStatus = 'open' | 'resolved' | 'archived';
+export type FeedbackSource = 'sdk' | 'widget';
+export type FeedbackWidgetTarget = 'preview' | 'publication';
+export interface FeedbackWidgetConfig {
+    targets: FeedbackWidgetTarget[];
+    label?: string;
+    types?: FeedbackType[];
+}
+export interface ConfigureFeedbackInput {
+    widget: FeedbackWidgetConfig | null;
+}
+export interface SubmitFeedbackInput {
+    type: FeedbackType;
+    message: string;
+    author?: {
+        externalId?: string;
+        name?: string;
+        email?: string;
+    };
+    context?: {
+        url?: string;
+        path?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface FeedbackData {
+    id: string;
+    type: FeedbackType;
+    message: string;
+    status: FeedbackStatus;
+    source: FeedbackSource;
+    author: {
+        source: 'external' | 'phpsandbox';
+        externalId: string | null;
+        phpsandboxUserId: number | null;
+        name: string | null;
+        email: string | null;
+    };
+    context: {
+        url: string | null;
+        path: string | null;
+        publication: {
+            id: string;
+            releaseId: string | null;
+        } | null;
+    };
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface FeedbackListOptions {
+    type?: FeedbackType;
+    status?: FeedbackStatus;
+    source?: FeedbackSource;
+    page?: number;
+}
+export interface UpdateFeedbackInput {
+    status: FeedbackStatus;
+}
+export declare class Feedback {
+    private readonly client;
+    private readonly notebookId;
+    constructor(client: Client, notebookId: string);
+    configure(input: ConfigureFeedbackInput): Promise<ConfigureFeedbackInput>;
+    configuration(): Promise<ConfigureFeedbackInput>;
+    submit(input: SubmitFeedbackInput): Promise<FeedbackData>;
+    list(options?: FeedbackListOptions): Promise<PaginatedApiResponse<FeedbackData>>;
+    get(id: string): Promise<FeedbackData>;
+    update(id: string, input: UpdateFeedbackInput): Promise<FeedbackData>;
+    private path;
+}

package/dist/feedback.js

@@ -0,0 +1,38 @@
+export class Feedback {
+    constructor(client, notebookId) {
+        this.client = client;
+        this.notebookId = notebookId;
+    }
+    async configure(input) {
+        const response = await this.client.put(this.path('/configuration'), input);
+        return response.data;
+    }
+    async configuration() {
+        const response = await this.client.get(this.path('/configuration'));
+        return response.data;
+    }
+    async submit(input) {
+        const response = await this.client.post(this.path(), input);
+        return response.data;
+    }
+    async list(options = {}) {
+        const query = new URLSearchParams();
+        for (const [name, value] of Object.entries(options)) {
+            if (value !== undefined)
+                query.set(name, String(value));
+        }
+        const response = await this.client.get(`${this.path()}${query.size === 0 ? '' : `?${query.toString()}`}`);
+        return response.data;
+    }
+    async get(id) {
+        const response = await this.client.get(this.path(`/${encodeURIComponent(id)}`));
+        return response.data;
+    }
+    async update(id, input) {
+        const response = await this.client.patch(this.path(`/${encodeURIComponent(id)}`), input);
+        return response.data;
+    }
+    path(suffix = '') {
+        return `/notebook/${this.notebookId}/feedback${suffix}`;
+    }
+}

package/dist/filesystem.d.ts

@@ -1,10 +1,5 @@
 import type { Action, Disposable, NotebookInstance } from './index.js';
 import { ErrorEvent } from './types.js';
-export interface FileInfo {
-    binary: boolean;
-    contents: string | null;
-    language: string;
-}
 export interface FileResult {
     name: string;
     directory: string;
@@ -361,24 +356,6 @@ export interface ReadFileRangeResult {
     error: string | null;
 }
 export interface FilesystemActions {
-    'fs.info': Action<{
-        path: string;
-    }, FileInfo>;
-    'fs.write': Action<{
-        path: string;
-        contents: string;
-    }, boolean>;
-    'fs.mkdir': Action<{
-        path: string;
-    }, boolean>;
-    'fs.remove': Action<{
-        path: string;
-        type: 'file' | 'directory';
-    }, boolean>;
-    'fs.move': Action<{
-        from: string;
-        to: string;
-    }, boolean>;
     'fs.find': Action<{
         query: string;
         options: FileSearchOptions;
@@ -472,7 +449,9 @@ export interface FilesystemActions {
     'fs.tail': Action<{
         path: string;
         lines: number;
-    }, string>;
+    }, {
+        content: string;
+    }>;
 }
 interface FilesystemEventData {
     'fs.watch': FileChange;

package/dist/filesystem.js

@@ -356,7 +356,9 @@ export class Filesystem {
             .finally(() => disposable.dispose());
     }
     tail(path, options = {}) {
-        return this.okra.invoke('fs.tail', { path, lines: options.lines ?? 10 }).catch((e) => this.handleError(e));
+        return this.okra.invoke('fs.tail', { path, lines: options.lines ?? 10 })
+            .then(({ content }) => content)
+            .catch((e) => this.handleError(e));
     }
     stat(path) {
         return this.okra.invoke('fs.stat', { path }).catch((e) => this.handleError(e));

package/dist/git.d.ts

@@ -1,4 +1,4 @@
-import type { Client, SecretRef } from './index.js';
+import type { Client } from './index.js';
 import { Action, NotebookInstance } from './index.js';
 export interface GitLog {
     hash: string;
@@ -50,35 +50,37 @@ export interface GitCredentials {
     expiresAt: string;
 }
 export type GitProvider = 'github' | (string & {});
-export type GitRepositoryVisibility = 'private' | 'public';
 export type GitSyncDirection = 'pull' | 'push' | 'both';
 export interface GitSyncAuthor {
     name: string;
     email: string;
 }
-export interface GitSyncTargetInput {
+export interface GitTargetConfiguration {
     provider: GitProvider;
     repository: string;
     author: GitSyncAuthor;
     branch?: string;
-    credential: SecretRef;
-    direction?: GitSyncDirection;
-    visibility?: GitRepositoryVisibility;
     setDefault?: boolean;
 }
-export interface GitSyncTargetData {
+export type CreateGitTargetInput = GitTargetConfiguration;
+export interface GitSyncExistingTargetInput {
+    direction?: GitSyncDirection;
+    author?: GitSyncAuthor;
+    force?: boolean;
+}
+export interface GitTargetData {
     id: string;
     provider: GitProvider;
     repository: string;
     url: string | null;
     branch: string;
-    credentialConfigured: boolean;
     default: boolean;
     lastCommitSha: string | null;
     lastSyncedAt: string | null;
     createdAt: string | null;
     updatedAt: string | null;
 }
+export type GitTargetReference = string | GitTarget;
 export interface GitCheckoutResult extends GitRef {
     branch: string;
     created: boolean;
@@ -213,11 +215,10 @@ export interface GitActions {
 export default class Git {
     protected okra: NotebookInstance;
     private readonly client;
+    readonly targets: GitTargetApi;
     constructor(okra: NotebookInstance, client: Client);
     checkpoint(author: string, message: string, branch?: string, allowEmpty?: boolean): Promise<GitRef>;
     checkout(branch: string, create?: boolean): Promise<GitCheckoutResult>;
-    sync(input: GitSyncTargetInput): Promise<GitSyncTargetData>;
-    syncTargets(): Promise<GitSyncTargetData[]>;
     log(ref?: string): Promise<GitLog[]>;
     diff(input: GitDiffInput): Promise<GitDiffPreview>;
     merge(input: GitMergeInput): Promise<GitMergeResult>;
@@ -233,6 +234,22 @@ export default class Git {
     status(): Promise<GitStatus>;
     private normalizeRemoteInput;
     private gitUrlForNotebook;
-    private omitUndefined;
+}
+export declare class GitTargetApi {
+    private readonly notebookId;
+    private readonly client;
+    constructor(notebookId: string, client: Client);
+    create(input: CreateGitTargetInput): Promise<GitTarget>;
+    list(): Promise<GitTarget[]>;
+    get(target: GitTargetReference): Promise<GitTarget>;
+    sync(target: GitTargetReference, input?: GitSyncExistingTargetInput): Promise<GitTarget>;
+}
+export declare class GitTarget {
+    readonly data: GitTargetData;
+    private readonly notebookId;
+    private readonly client;
+    constructor(data: GitTargetData, notebookId: string, client: Client);
+    get id(): string;
+    sync(input?: GitSyncExistingTargetInput): Promise<GitTarget>;
 }
 export {};

package/dist/git.js

@@ -2,6 +2,7 @@ export default class Git {
     constructor(okra, client) {
         this.okra = okra;
         this.client = client;
+        this.targets = new GitTargetApi(okra.data.id, client);
     }
     checkpoint(author, message, branch = 'main', allowEmpty = false) {
         return this.okra.invoke('git.checkpoint', { author, message, branch, allowEmpty });
@@ -9,14 +10,6 @@ export default class Git {
     checkout(branch, create = true) {
         return this.okra.invoke('git.checkout', { branch, create });
     }
-    async sync(input) {
-        const response = await this.client.post(`/notebook/${this.okra.data.id}/git/sync-targets`, this.omitUndefined({ ...input }));
-        return response.data;
-    }
-    async syncTargets() {
-        const response = await this.client.get(`/notebook/${this.okra.data.id}/git/sync-targets`);
-        return response.data;
-    }
     log(ref = 'main') {
         return this.okra.invoke('git.log', { ref });
     }
@@ -85,7 +78,45 @@ export default class Git {
         url.hash = '';
         return url.toString();
     }
-    omitUndefined(input) {
-        return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+export class GitTargetApi {
+    constructor(notebookId, client) {
+        this.notebookId = notebookId;
+        this.client = client;
+    }
+    async create(input) {
+        const response = await this.client.post(`/notebook/${this.notebookId}/git/targets`, omitUndefined({ ...input }));
+        return new GitTarget(response.data, this.notebookId, this.client);
+    }
+    async list() {
+        const response = await this.client.get(`/notebook/${this.notebookId}/git/targets`);
+        return response.data.map((target) => new GitTarget(target, this.notebookId, this.client));
+    }
+    async get(target) {
+        const response = await this.client.get(`/notebook/${this.notebookId}/git/targets/${encodeURIComponent(gitTargetId(target))}`);
+        return new GitTarget(response.data, this.notebookId, this.client);
+    }
+    async sync(target, input = {}) {
+        const response = await this.client.post(`/notebook/${this.notebookId}/git/targets/${encodeURIComponent(gitTargetId(target))}/sync`, omitUndefined({ ...input }));
+        return new GitTarget(response.data, this.notebookId, this.client);
     }
 }
+export class GitTarget {
+    constructor(data, notebookId, client) {
+        this.data = data;
+        this.notebookId = notebookId;
+        this.client = client;
+    }
+    get id() {
+        return this.data.id;
+    }
+    sync(input = {}) {
+        return new GitTargetApi(this.notebookId, this.client).sync(this, input);
+    }
+}
+function gitTargetId(target) {
+    return typeof target === 'string' ? target : target.id;
+}
+function omitUndefined(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}

package/dist/index.d.ts

@@ -17,6 +17,9 @@ import { Disposable } from './types.js';
 import { NotebookUnavailableError } from './errors/index.js';
 import { PublicationApi, NotebookPublicationApi, type PublicationInstance, type PublicationRun, type PublishInput } from './publications.js';
 import { ServerApi } from './servers.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';
@@ -34,6 +37,9 @@ 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';
 interface Result<TType extends 'success' | 'error' | 'running', TData extends object> {
     type: TType;
     message: string;
@@ -314,6 +320,7 @@ export declare class Client {
     readonly notebook: NotebookApi;
     readonly publications: PublicationApi;
     readonly servers: ServerApi;
+    readonly integrations: IntegrationApi;
     readonly options: PHPSandboxClientOptions;
     protected runtimeTransportValue: RuntimeTransport;
     get runtimeTransport(): RuntimeTransport;
@@ -333,6 +340,9 @@ export declare class Client {
     put<T extends unknown>(path: string, body?: unknown): Promise<{
         data: T;
     }>;
+    patch<T extends unknown>(path: string, body?: unknown): Promise<{
+        data: T;
+    }>;
     stream(path: string): Promise<ReadableStream<Uint8Array>>;
     sse(url: string): Promise<ReadableStream<Uint8Array>>;
     private makeRequest;
@@ -404,8 +414,10 @@ export declare class NotebookInstance {
     readonly services: Services;
     readonly config: Config;
     readonly secrets: NotebookSecrets;
+    readonly integrations: SandboxIntegrationApi;
     readonly preview: NotebookPreview;
     readonly mail: NotebookMail;
+    readonly feedback: Feedback;
     private readonly socket;
     private readonly restInvoker;
     readonly emitter: EventDispatcher;

package/dist/index.js

@@ -31,6 +31,9 @@ import { NotebookUnavailableError, UnsupportedRuntimeTransportError } from './er
 import { PublicationApi, NotebookPublicationApi } 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';
@@ -48,6 +51,9 @@ 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';
 function normalizeNotebookSecretInputs(input) {
     if (Array.isArray(input)) {
         return input;
@@ -159,6 +165,7 @@ export class Client {
         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.baseUrl = normalizeApiBaseUrl(url);
         if (options.fetch) {
@@ -182,6 +189,9 @@ export class Client {
     put(path, body) {
         return this.makeRequest('PUT', path, { body: body === undefined ? undefined : JSON.stringify(body) });
     }
+    patch(path, body) {
+        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), {
             method: 'GET',
@@ -390,8 +400,10 @@ export class NotebookInstance {
         this.services = new Services(this);
         this.config = new Config(this);
         this.secrets = new NotebookSecrets(client, this.data.id);
+        this.integrations = new SandboxIntegrationApi(this.data.id, client);
         this.preview = new NotebookPreview(client, this.data.id);
         this.mail = new NotebookMail(client, this.data.id);
+        this.feedback = new Feedback(client, this.data.id);
     }
     async ready() {
         if (this.restInvoker !== null) {

package/dist/integrations.d.ts

@@ -0,0 +1,43 @@
+import type { Client } from './index.js';
+export type IntegrationProvider = 'cloudflare' | 'github' | 'laravel-cloud';
+export type IntegrationAuthorizationType = 'token';
+export interface IntegrationAuthorization {
+    type: IntegrationAuthorizationType;
+    token: string;
+}
+export interface LinkIntegrationInput {
+    provider: IntegrationProvider;
+    label?: string | null;
+    authorization: IntegrationAuthorization;
+}
+export interface UpdateIntegrationInput {
+    label?: string | null;
+    authorization?: IntegrationAuthorization;
+}
+export interface IntegrationData {
+    id: string;
+    provider: IntegrationProvider;
+    label: string | null;
+    createdAt: string | null;
+}
+export type IntegrationReference = string | Integration;
+export declare class IntegrationApi {
+    private readonly client;
+    constructor(client: Client);
+    link(input: LinkIntegrationInput): Promise<Integration>;
+    list(): Promise<Integration[]>;
+    get(integration: IntegrationReference): Promise<Integration>;
+    update(integration: IntegrationReference, input: UpdateIntegrationInput): Promise<Integration>;
+    unlink(integration: IntegrationReference): Promise<void>;
+}
+export declare class Integration {
+    readonly data: IntegrationData;
+    private readonly client;
+    constructor(data: IntegrationData, client: Client);
+    get id(): string;
+    get provider(): IntegrationProvider;
+    get label(): string | null;
+    update(input: UpdateIntegrationInput): Promise<Integration>;
+    unlink(): Promise<void>;
+}
+export declare function integrationId(integration: IntegrationReference): string;

package/dist/integrations.js

@@ -0,0 +1,48 @@
+export class IntegrationApi {
+    constructor(client) {
+        this.client = client;
+    }
+    async link(input) {
+        const response = await this.client.post('/integrations', input);
+        return new Integration(response.data, this.client);
+    }
+    async list() {
+        const response = await this.client.get('/integrations');
+        return response.data.map((integration) => new Integration(integration, this.client));
+    }
+    async get(integration) {
+        const response = await this.client.get(`/integrations/${encodeURIComponent(integrationId(integration))}`);
+        return new Integration(response.data, this.client);
+    }
+    async update(integration, input) {
+        const response = await this.client.patch(`/integrations/${encodeURIComponent(integrationId(integration))}`, input);
+        return new Integration(response.data, this.client);
+    }
+    async unlink(integration) {
+        await this.client.delete(`/integrations/${encodeURIComponent(integrationId(integration))}`);
+    }
+}
+export class Integration {
+    constructor(data, client) {
+        this.data = data;
+        this.client = client;
+    }
+    get id() {
+        return this.data.id;
+    }
+    get provider() {
+        return this.data.provider;
+    }
+    get label() {
+        return this.data.label;
+    }
+    update(input) {
+        return new IntegrationApi(this.client).update(this, input);
+    }
+    unlink() {
+        return new IntegrationApi(this.client).unlink(this);
+    }
+}
+export function integrationId(integration) {
+    return typeof integration === 'string' ? integration : integration.id;
+}

package/dist/publications.d.ts

@@ -1,4 +1,4 @@
-import { type Client, type SecretRef } from './index.js';
+import { type Client } 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 {
@@ -13,10 +13,6 @@ export interface PublicationProtectionData {
     expiresAt?: string;
     url?: string;
 }
-export interface PublicationFeedbackData {
-    enabled: boolean;
-    config: Record<string, unknown>;
-}
 export type PublicationProtectionInput = {
     mode: 'none';
     password?: never;
@@ -24,11 +20,8 @@ export type PublicationProtectionInput = {
     mode: 'password';
     password: string;
 };
-export interface PublicationFeedbackInput {
-    enabled: boolean;
-    config?: Record<string, unknown>;
-}
 export interface CloudflareContainersProviderOptions {
+    accountId: string;
     size?: PublicationSize;
     sleepAfter?: string;
     placement?: PublicationPlacement;
@@ -42,11 +35,9 @@ export interface LaravelCloudProviderData {
     repository?: string;
     branch?: string;
     sourceControlProviderType?: 'github' | 'gitlab' | 'bitbucket';
-    apiKeyConfigured?: boolean;
 }
 export interface LaravelCloudProviderInput {
-    apiKey: SecretRef;
-    region?: LaravelCloudRegion;
+    region: LaravelCloudRegion;
 }
 export interface PublicationProviderInputs {
     'cloudflare-containers': CloudflareContainersProviderOptions;
@@ -73,9 +64,9 @@ export interface PublishInput<TName extends PublicationProviderName = Publicatio
     slug: string;
     provider: PublicationProviderInput<TName>;
     protection?: PublicationProtectionInput;
-    feedback?: PublicationFeedbackInput;
     metadata?: Record<string, unknown>;
 }
+export type PublicationRunResult = PublishStreamResult;
 export interface PublicationBuildData<TProvider extends PublicationProviderName = PublicationProviderName> {
     id: string;
     status: PublicationBuildStatus;
@@ -124,7 +115,6 @@ export interface PublicationData<TProvider extends PublicationProviderName = Pub
     strategy: string;
     provider: PublicationProvider<TProvider>;
     protection: PublicationProtectionData;
-    feedback: PublicationFeedbackData;
     eventStreamUrl: string | null;
     originUrl: string | null;
     currentRelease?: PublicationReleaseData | null;
@@ -144,10 +134,6 @@ export interface PublicationProtectionSessionData {
     expiresAt: string;
     url: string;
 }
-export interface UpdatePublicationFeedbackInput {
-    enabled: boolean;
-    config?: Record<string, unknown>;
-}
 export declare class NotebookPublicationApi {
     private readonly client;
     constructor(client: Client);
@@ -163,7 +149,6 @@ export declare class PublicationApi {
     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>;
@@ -186,7 +171,7 @@ export declare class PublicationRun<TProvider extends PublicationProviderName =
     private readonly subscribers;
     constructor(initial: PublicationInstance<TProvider>, client: Client);
     events(): AsyncIterable<PublishStreamEvent>;
-    result(): Promise<PublishStreamResult>;
+    result(): Promise<PublicationRunResult>;
     publication(): Promise<PublicationInstance<TProvider>>;
     start(): this;
     private subscribe;
@@ -214,7 +199,6 @@ export declare class PublicationInstance<TProvider extends PublicationProviderNa
     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>;

package/dist/publications.js

@@ -51,10 +51,6 @@ export class PublicationApi {
         const response = await this.client.delete(`/publications/${id}/protection`);
         return new PublicationInstance(response.data, this.client);
     }
-    async setFeedback(id, input) {
-        const response = await this.client.put(`/publications/${id}/feedback`, input);
-        return new PublicationInstance(response.data, this.client);
-    }
     async listDomains(id) {
         const response = await this.client.get(`/publications/${id}/domains`);
         return unwrapPublicationDomainCollection(response.data);
@@ -156,7 +152,7 @@ export class PublicationRun {
                 if (event.type === 'result') {
                     const { type: _, ...result } = event;
                     this.finalResult = result;
-                    this.resolveResult?.(result);
+                    this.resolveResult?.(this.finalResult);
                 }
             }
             if (!this.finalResult) {
@@ -248,9 +244,6 @@ export class PublicationInstance {
     disableProtection() {
         return this.client.publications.disableProtection(this.data.id);
     }
-    setFeedback(input) {
-        return this.client.publications.setFeedback(this.data.id, input);
-    }
     domains() {
         return this.client.publications.listDomains(this.data.id);
     }

package/dist/runtime/rest.js

@@ -15,18 +15,13 @@ const restActionRoutes = {
     'container.stats': { method: 'GET', path: '/runtime/container/stats' },
     'terminal.list': { method: 'GET', path: '/runtime/terminals' },
     'shell.exec': { method: 'POST', path: '/runtime/executions' },
-    'fs.info': { method: 'POST', path: '/runtime/files/info' },
     'fs.readFile': { method: 'GET', path: '/runtime/files/content' },
     'fs.writeFile': { method: 'PUT', path: '/runtime/files/content' },
-    'fs.write': { method: 'PUT', path: '/runtime/files/text' },
-    'fs.mkdir': { method: 'POST', path: '/runtime/directories' },
     'fs.createDirectory': { method: 'PUT', path: '/runtime/directories' },
     'fs.readDirectory': { method: 'POST', path: '/runtime/directories/read' },
     'fs.stat': { method: 'POST', path: '/runtime/files/stat' },
-    'fs.move': { method: 'POST', path: '/runtime/files/move' },
     'fs.rename': { method: 'POST', path: '/runtime/files/rename' },
     'fs.copy': { method: 'POST', path: '/runtime/files/copy' },
-    'fs.remove': { method: 'POST', path: '/runtime/files/remove' },
     'fs.delete': { method: 'DELETE', path: '/runtime/files' },
     'fs.tail': { method: 'POST', path: '/runtime/files/tail' },
     'fs.find': { method: 'POST', path: '/runtime/files/find' },