dataiku-sdk 0.7.0 → 0.9.0

package/dist/src/resources/project-library.js

@@ -0,0 +1,82 @@
+import { BaseResource, } from "./base.js";
+function normalizeLibraryPath(path) {
+    const normalized = path.replace(/^\/+/, "");
+    if (!normalized)
+        throw new Error("Project library path is required");
+    return normalized;
+}
+function normalizeLibraryDestinationPath(path) {
+    if (path === "/")
+        return "/";
+    return `/${normalizeLibraryPath(path)}`;
+}
+function encodeLibraryPath(path) {
+    const normalized = normalizeLibraryPath(path);
+    return normalized
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+export class ProjectLibraryResource extends BaseResource {
+    /** List the full project code-library contents tree. */
+    async listContents(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/libraries/contents`);
+    }
+    /** Read a project code-library file as text. */
+    async getFile(path, projectKey) {
+        const res = await this.client.get(this.contentsPath(path, projectKey));
+        return res.data;
+    }
+    /** Read a project code-library file as bytes. */
+    async getFileBytes(path, projectKey) {
+        const res = await this.client.get(`${this.contentsPath(path, projectKey)}?dataEncoding=base64`);
+        return Buffer.from(res.data, "base64");
+    }
+    /** Create an empty project code-library file. */
+    async addFile(path, projectKey) {
+        await this.client.postText(this.contentsPath(path, projectKey));
+    }
+    /** Create a project code-library folder. */
+    async addFolder(path, projectKey) {
+        await this.client.postText(`/public/api/projects/${this.enc(projectKey)}/libraries/folders/${encodeLibraryPath(path)}`);
+    }
+    /** Create or replace a project code-library file with raw text content. */
+    async addOrUpdateFile(path, content, projectKey) {
+        await this.postRawText(this.contentsPath(path, projectKey), content);
+    }
+    /** Delete a project code-library file. */
+    async deleteFile(path, projectKey) {
+        await this.client.del(this.contentsPath(path, projectKey));
+    }
+    /** Rename a project code-library file or folder within its current parent folder. */
+    async rename(path, newName, projectKey) {
+        const body = {
+            oldPath: `/${normalizeLibraryPath(path)}`,
+            newName,
+        };
+        await this.client.postText(`/public/api/projects/${this.enc(projectKey)}/libraries/contents-actions/rename/`, body);
+    }
+    /** Move a project code-library file or folder into another library folder. */
+    async move(path, destinationFolderPath, projectKey) {
+        const body = {
+            oldPath: `/${normalizeLibraryPath(path)}`,
+            newPath: normalizeLibraryDestinationPath(destinationFolderPath),
+        };
+        await this.client.postText(`/public/api/projects/${this.enc(projectKey)}/libraries/contents-actions/move`, body);
+    }
+    contentsPath(path, projectKey) {
+        const projectKeyPart = this.enc(projectKey);
+        return `/public/api/projects/${projectKeyPart}/libraries/contents/${encodeLibraryPath(path)}`;
+    }
+    async postRawText(path, content) {
+        // DSS library writes use dataikuapi's raw_body; route through the client's
+        // transport so auth, retries, TLS options, and DSS error handling stay aligned.
+        const rawClient = this.client;
+        const res = await rawClient.fetchWithRetry(`${rawClient.baseUrl}${path}`, {
+            method: "POST",
+            headers: rawClient.getAnyHeaders(),
+            body: content,
+        });
+        await res.text();
+    }
+}

package/dist/src/resources/projects.d.ts

@@ -15,7 +15,77 @@ export interface FlowMapResult {
     truncation: FlowMapTruncationSummary;
     raw?: unknown;
 }
+export type ProjectLifecycleSettings = Record<string, unknown>;
+export type ProjectDuplicationMode = "MINIMAL" | "SHARING" | "FULL" | "NONE" | (string & {});
+export interface ProjectDuplicateOptions {
+    duplicationMode?: ProjectDuplicationMode;
+    exportAnalysisModels?: boolean;
+    exportSavedModels?: boolean;
+    exportGitRepository?: boolean | null;
+    exportInsightsData?: boolean;
+    remapping?: Record<string, unknown>;
+    targetProjectFolderId?: string;
+}
+export interface ProjectExportOptions {
+    exportUploads?: boolean;
+    exportManagedFS?: boolean;
+    exportAnalysisModels?: boolean;
+    exportSavedModels?: boolean;
+    exportModelEvaluationStores?: boolean;
+    exportManagedFolders?: boolean;
+    exportAllInputDatasets?: boolean;
+    exportAllDatasets?: boolean;
+    exportAllInputManagedFolders?: boolean;
+    exportGitRepository?: boolean;
+    exportInsightsData?: boolean;
+    exportPromptStudioHistories?: boolean;
+    [key: string]: unknown;
+}
+export interface ProjectPermissionRule {
+    group?: string;
+    user?: string;
+    admin?: boolean;
+    readProjectContent?: boolean;
+    writeProjectContent?: boolean;
+    readDashboards?: boolean;
+    writeDashboards?: boolean;
+    runScenarios?: boolean;
+    manageDashboardAuthorizations?: boolean;
+    manageExposedElements?: boolean;
+    moderateDashboards?: boolean;
+    [key: string]: unknown;
+}
+export interface ProjectPermissions {
+    owner?: string;
+    permissions?: ProjectPermissionRule[];
+    [key: string]: unknown;
+}
+export interface ProjectImportUploadResult {
+    id: string;
+    [key: string]: unknown;
+}
 export declare class ProjectsResource extends BaseResource {
+    private httpInternals;
+    private postStream;
+    private uploadJson;
+    /** Create a new project. */
+    createProject(projectKey: string, name: string, ownerLogin?: string, settings?: ProjectLifecycleSettings | null): Promise<string>;
+    /** Delete a project using the lifecycle endpoint. */
+    deleteProject(projectKey: string, dropData?: boolean): Promise<void>;
+    /** Duplicate a project. */
+    duplicate(projectKey: string, targetProjectKey: string, targetProjectName: string, options?: ProjectDuplicateOptions): Promise<Record<string, unknown>>;
+    /** Export a project archive to a local file. */
+    exportArchive(projectKey: string, filePath: string, options?: ProjectExportOptions): Promise<void>;
+    /** Upload a project archive and return the temporary import id. */
+    importProjectFromArchive(filePath: string): Promise<ProjectImportUploadResult>;
+    /** Get project permissions. */
+    getPermissions(projectKey?: string): Promise<ProjectPermissions>;
+    /** Set project permissions. */
+    setPermissions(projectKey: string | undefined, permissions: ProjectPermissions): Promise<void>;
+    /** Get project settings. */
+    getSettings(projectKey?: string): Promise<ProjectLifecycleSettings>;
+    /** Set project settings. */
+    setSettings(projectKey: string | undefined, body: ProjectLifecycleSettings): Promise<void>;
     /** List all projects visible to the API key. */
     list(): Promise<ProjectSummary[]>;
     /** Get details for a single project. */

package/dist/src/resources/projects.js

@@ -1,3 +1,5 @@
+import { createWriteStream, openAsBlob, } from "node:fs";
+import { Writable, } from "node:stream";
 import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, } from "../schemas.js";
 import { normalizeFlowGraph, } from "../utils/flow-map.js";
 import { BaseResource, } from "./base.js";
@@ -99,6 +101,101 @@ const DEFAULT_MAX_NODES = 300;
 const DEFAULT_MAX_EDGES = 600;
 const DEFAULT_METADATA_TIMEOUT_MS = 1_500;
 export class ProjectsResource extends BaseResource {
+    httpInternals() {
+        return this.client;
+    }
+    async postStream(path, body) {
+        const http = this.httpInternals();
+        return http.fetchWithRetry(`${http.baseUrl}${path}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${http.apiKey}`,
+                Accept: "*/*",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    async uploadJson(path, filePath, fileName) {
+        const http = this.httpInternals();
+        const fileBlob = await openAsBlob(filePath);
+        const formData = new FormData();
+        formData.append("file", fileBlob, fileName);
+        const res = await http.fetchWithRetry(`${http.baseUrl}${path}`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${http.apiKey}`, },
+            body: formData,
+        });
+        return res.json();
+    }
+    /** Create a new project. */
+    async createProject(projectKey, name, ownerLogin, settings) {
+        return this.client.postText("/public/api/projects/", {
+            projectKey,
+            name,
+            owner: ownerLogin ?? null,
+            settings: settings ?? null,
+            description: null,
+            permissions: [],
+            tags: [],
+        });
+    }
+    /** Delete a project using the lifecycle endpoint. */
+    async deleteProject(projectKey, dropData = false) {
+        const enc = encodeURIComponent(projectKey);
+        await this.client.del(`/public/api/projects/${enc}?clearManagedDatasets=${String(dropData)}&clearOutputManagedFolders=false&clearJobAndScenarioLogs=true&wait=true`);
+    }
+    /** Duplicate a project. */
+    async duplicate(projectKey, targetProjectKey, targetProjectName, options) {
+        const body = {
+            targetProjectName,
+            targetProjectKey,
+            duplicationMode: options?.duplicationMode ?? "MINIMAL",
+            exportAnalysisModels: options?.exportAnalysisModels ?? true,
+            exportSavedModels: options?.exportSavedModels ?? true,
+            exportGitRepository: options?.exportGitRepository ?? null,
+            exportInsightsData: options?.exportInsightsData ?? true,
+            remapping: options?.remapping ?? {},
+            ...(options?.targetProjectFolderId !== undefined
+                ? { targetProjectFolderId: options.targetProjectFolderId, }
+                : {}),
+        };
+        return this.client.post(`/public/api/projects/${encodeURIComponent(projectKey)}/duplicate/`, body);
+    }
+    /** Export a project archive to a local file. */
+    async exportArchive(projectKey, filePath, options) {
+        const res = await this.postStream(`/public/api/projects/${encodeURIComponent(projectKey)}/export`, options ?? {});
+        if (!res.body)
+            throw new Error("projects.exportArchive response did not include a body");
+        const file = createWriteStream(filePath);
+        try {
+            await res.body.pipeTo(Writable.toWeb(file));
+        }
+        catch (error) {
+            file.destroy();
+            throw error;
+        }
+    }
+    /** Upload a project archive and return the temporary import id. */
+    async importProjectFromArchive(filePath) {
+        return this.uploadJson("/public/api/projects/import/upload", filePath, "tmp-import.zip");
+    }
+    /** Get project permissions. */
+    async getPermissions(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/permissions`);
+    }
+    /** Set project permissions. */
+    async setPermissions(projectKey, permissions) {
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/permissions`, permissions);
+    }
+    /** Get project settings. */
+    async getSettings(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/settings`);
+    }
+    /** Set project settings. */
+    async setSettings(projectKey, body) {
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/settings`, body);
+    }
     /** List all projects visible to the API key. */
     async list() {
         const raw = await this.client.get("/public/api/projects/");

package/dist/src/resources/recipes.js

@@ -111,16 +111,18 @@ function escapedRegExp(value) {
 function isSqlRecipeType(recipeType) {
     return typeof recipeType === "string" && recipeType.toLowerCase().includes("sql");
 }
+function escapeQuotedIdentifier(identifier, quote) {
+    if (quote === '"')
+        return identifier.replace(/"/g, '""');
+    if (quote === "`")
+        return identifier.replace(/`/g, "``");
+    return identifier;
+}
+function escapeBracketIdentifier(identifier) {
+    return identifier.replace(/\]/g, "]]");
+}
 function rewriteSqlTableReferences(payload, rewrites) {
     const bareIdentifierPattern = /^[A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)*$/;
-    const escapeQuotedIdentifier = (identifier, quote) => {
-        if (quote === "\"")
-            return identifier.replace(/"/g, '""');
-        if (quote === "`")
-            return identifier.replace(/`/g, "``");
-        return identifier;
-    };
-    const escapeBracketIdentifier = (identifier) => identifier.replace(/\]/g, "]]");
     let next = payload;
     for (const [from, to,] of Object.entries(rewrites)) {
         if (!from)

package/dist/src/resources/scenarios.d.ts

@@ -40,6 +40,8 @@ export interface ScenarioScriptRunResult {
     pollCount: number;
     output?: string;
     log: string;
+    logTruncated: boolean;
+    maxLogBytes: number;
     envName?: string;
 }
 export declare function normalizeScenarioUpdateData(data: Record<string, unknown>): {
@@ -91,5 +93,6 @@ export declare class ScenariosResource extends BaseResource {
         timeoutMs?: number;
         pollIntervalMs?: number;
         keepScenario?: boolean;
+        maxLogBytes?: number;
     }): Promise<ScenarioScriptRunResult>;
 }

package/dist/src/resources/scenarios.js

@@ -12,6 +12,7 @@ export const SCENARIO_CANONICAL_EDITABLE_FIELDS = [
     "active",
     "name",
 ];
+const DEFAULT_CODE_RUN_MAX_LOG_BYTES = 1_048_576;
 const CODE_RUN_OUTPUT_START = "<<<DSS_CODE_RUN_OUTPUT_b7e3a1>>>";
 const CODE_RUN_OUTPUT_END = "<<<DSS_CODE_RUN_OUTPUT_END_b7e3a1>>>";
 /**
@@ -349,6 +350,7 @@ export class ScenariosResource extends BaseResource {
         const baseIntervalMs = Math.max(1, opts?.pollIntervalMs ?? 2_000);
         const adaptivePolling = opts?.pollIntervalMs === undefined;
         const timeout = Math.max(baseIntervalMs, opts?.timeoutMs ?? 120_000);
+        const maxLogBytes = Math.max(0, Math.floor(opts?.maxLogBytes ?? DEFAULT_CODE_RUN_MAX_LOG_BYTES));
         try {
             await this.client.post(`/public/api/projects/${pkEnc}/scenarios/`, {
                 id: scenarioId,
@@ -394,8 +396,11 @@ export class ScenariosResource extends BaseResource {
                 await new Promise((r) => setTimeout(r, Math.min(nextDelayMs, Math.max(1, timeout - (Date.now() - startedAt)))));
             }
             let log = "";
+            let logTruncated = false;
             if (runId && outcome !== "TIMEOUT") {
-                log = await this.client.getText(`${base}/${encodeURIComponent(runId)}/log`);
+                const limitedLog = await this.client.getTextLimited(`${base}/${encodeURIComponent(runId)}/log`, maxLogBytes);
+                log = limitedLog.text;
+                logTruncated = limitedLog.truncated;
             }
             const output = extractCodeRunOutput(log);
             return {
@@ -407,6 +412,8 @@ export class ScenariosResource extends BaseResource {
                 pollCount,
                 output,
                 log,
+                logTruncated,
+                maxLogBytes,
                 ...(opts?.envName ? { envName: opts.envName, } : {}),
             };
         }

package/dist/src/resources/statistics.d.ts

@@ -0,0 +1,56 @@
+import { BaseResource } from "./base.js";
+export type StatisticsCardSettings = Record<string, unknown>;
+export type StatisticsComputationSettings = Record<string, unknown>;
+export interface StatisticsDatasetSelection {
+    partitionSelectionMethod?: string;
+    maxRecords?: number;
+    samplingMethod?: string;
+    [key: string]: unknown;
+}
+export interface StatisticsWorksheetDataSpec {
+    inputDatasetSmartName?: string;
+    datasetSelection?: StatisticsDatasetSelection;
+    [key: string]: unknown;
+}
+export interface StatisticsWorksheetCreateRequest {
+    projectKey?: string;
+    name?: string;
+    dataSpec?: StatisticsWorksheetDataSpec;
+    rootCard?: StatisticsCardSettings;
+    [key: string]: unknown;
+}
+export interface StatisticsWorksheetUpdateRequest extends StatisticsWorksheetCreateRequest {
+    id?: string;
+}
+export interface StatisticsWorksheet {
+    id: string;
+    projectKey?: string;
+    name?: string;
+    dataSpec?: StatisticsWorksheetDataSpec;
+    rootCard?: StatisticsCardSettings;
+    [key: string]: unknown;
+}
+export interface StatisticsFutureResponse {
+    jobId?: string | null;
+    [key: string]: unknown;
+}
+export declare class StatisticsResource extends BaseResource {
+    /** List statistics worksheets associated with a dataset. */
+    listWorksheets(datasetName: string, projectKey?: string): Promise<StatisticsWorksheet[]>;
+    /** Get one statistics worksheet definition. */
+    getWorksheet(datasetName: string, worksheetId: string, projectKey?: string): Promise<StatisticsWorksheet>;
+    /** Create a statistics worksheet for a dataset. */
+    createWorksheet(datasetName: string, body: StatisticsWorksheetCreateRequest, projectKey?: string): Promise<StatisticsWorksheet>;
+    /** Replace a statistics worksheet definition. */
+    updateWorksheet(datasetName: string, worksheetId: string, body: StatisticsWorksheetUpdateRequest, projectKey?: string): Promise<StatisticsWorksheet>;
+    /** Delete a statistics worksheet. */
+    deleteWorksheet(datasetName: string, worksheetId: string, projectKey?: string): Promise<void>;
+    /** Run the root card of a worksheet, returning the DSS future response. */
+    runWorksheet(datasetName: string, worksheetId: string, projectKey?: string): Promise<StatisticsFutureResponse>;
+    /** Run a card in the context of a worksheet, returning the DSS future response. */
+    runCard(datasetName: string, worksheetId: string, card: StatisticsCardSettings, projectKey?: string): Promise<StatisticsFutureResponse>;
+    /** Run a computation in the context of a worksheet, returning the DSS future response. */
+    runComputation(datasetName: string, worksheetId: string, computation: StatisticsComputationSettings, projectKey?: string): Promise<StatisticsFutureResponse>;
+    private worksheetsPath;
+    private worksheetPath;
+}

package/dist/src/resources/statistics.js

@@ -0,0 +1,51 @@
+import { BaseResource, } from "./base.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export class StatisticsResource extends BaseResource {
+    /** List statistics worksheets associated with a dataset. */
+    async listWorksheets(datasetName, projectKey) {
+        return this.client.get(this.worksheetsPath(datasetName, projectKey));
+    }
+    /** Get one statistics worksheet definition. */
+    async getWorksheet(datasetName, worksheetId, projectKey) {
+        return this.client.get(this.worksheetPath(datasetName, worksheetId, projectKey));
+    }
+    /** Create a statistics worksheet for a dataset. */
+    async createWorksheet(datasetName, body, projectKey) {
+        return this.client.post(this.worksheetsPath(datasetName, projectKey), body);
+    }
+    /** Replace a statistics worksheet definition. */
+    async updateWorksheet(datasetName, worksheetId, body, projectKey) {
+        return this.client.put(this.worksheetPath(datasetName, worksheetId, projectKey), body);
+    }
+    /** Delete a statistics worksheet. */
+    async deleteWorksheet(datasetName, worksheetId, projectKey) {
+        await this.client.del(this.worksheetPath(datasetName, worksheetId, projectKey));
+    }
+    /** Run the root card of a worksheet, returning the DSS future response. */
+    async runWorksheet(datasetName, worksheetId, projectKey) {
+        const worksheet = await this.getWorksheet(datasetName, worksheetId, projectKey);
+        if (!isRecord(worksheet.rootCard)) {
+            throw new Error("statistics.runWorksheet requires worksheet.rootCard");
+        }
+        return this.runCard(datasetName, worksheetId, worksheet.rootCard, projectKey);
+    }
+    /** Run a card in the context of a worksheet, returning the DSS future response. */
+    async runCard(datasetName, worksheetId, card, projectKey) {
+        return this.client.post(`${this.worksheetPath(datasetName, worksheetId, projectKey)}/actions/run-card`, card);
+    }
+    /** Run a computation in the context of a worksheet, returning the DSS future response. */
+    async runComputation(datasetName, worksheetId, computation, projectKey) {
+        return this.client.post(`${this.worksheetPath(datasetName, worksheetId, projectKey)}/actions/run-computation`, computation);
+    }
+    worksheetsPath(datasetName, projectKey) {
+        const project = this.enc(projectKey);
+        const dataset = encodeURIComponent(datasetName);
+        return `/public/api/projects/${project}/datasets/${dataset}/statistics/worksheets/`;
+    }
+    worksheetPath(datasetName, worksheetId, projectKey) {
+        const worksheet = encodeURIComponent(worksheetId);
+        return `${this.worksheetsPath(datasetName, projectKey)}${worksheet}`;
+    }
+}

package/dist/src/resources/streaming-endpoints.d.ts

@@ -0,0 +1,45 @@
+import { BaseResource } from "./base.js";
+export interface StreamingEndpointSchemaColumn {
+    name: string;
+    type: string;
+    length?: number;
+    comment?: string;
+    [key: string]: unknown;
+}
+export interface StreamingEndpointSchema {
+    columns: StreamingEndpointSchemaColumn[];
+    [key: string]: unknown;
+}
+export interface StreamingEndpointListItem {
+    id: string;
+    projectKey: string;
+    type: string;
+    schema?: StreamingEndpointSchema;
+    params?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface StreamingEndpointSettings {
+    id: string;
+    projectKey?: string;
+    type: string;
+    params?: Record<string, unknown>;
+    schema?: StreamingEndpointSchema;
+    [key: string]: unknown;
+}
+export interface StreamingEndpointCreateParams {
+    [key: string]: unknown;
+}
+export declare class StreamingEndpointsResource extends BaseResource {
+    /** List all streaming endpoints in a project. */
+    list(projectKey?: string): Promise<StreamingEndpointListItem[]>;
+    /** Get one streaming endpoint's settings. */
+    get(id: string, projectKey?: string): Promise<StreamingEndpointSettings>;
+    /** Get one streaming endpoint's settings. */
+    getSettings(id: string, projectKey?: string): Promise<StreamingEndpointSettings>;
+    /** Create a streaming endpoint with type-specific params. */
+    create(id: string, type: string, body: StreamingEndpointCreateParams, projectKey?: string): Promise<StreamingEndpointSettings>;
+    /** Update one streaming endpoint's raw settings. */
+    updateSettings(id: string, body: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /** Delete a streaming endpoint from the flow without deleting underlying streaming data. */
+    delete(id: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/streaming-endpoints.js

@@ -0,0 +1,36 @@
+import { BaseResource, } from "./base.js";
+export class StreamingEndpointsResource extends BaseResource {
+    /** List all streaming endpoints in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/streamingendpoints/`);
+    }
+    /** Get one streaming endpoint's settings. */
+    async get(id, projectKey) {
+        return this.getSettings(id, projectKey);
+    }
+    /** Get one streaming endpoint's settings. */
+    async getSettings(id, projectKey) {
+        const endpointId = encodeURIComponent(id);
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/streamingendpoints/${endpointId}`);
+    }
+    /** Create a streaming endpoint with type-specific params. */
+    async create(id, type, body, projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        return this.client.post(`/public/api/projects/${this.enc(pk)}/streamingendpoints/`, {
+            id,
+            projectKey: pk,
+            type,
+            params: body,
+        });
+    }
+    /** Update one streaming endpoint's raw settings. */
+    async updateSettings(id, body, projectKey) {
+        const endpointId = encodeURIComponent(id);
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/streamingendpoints/${endpointId}`, body);
+    }
+    /** Delete a streaming endpoint from the flow without deleting underlying streaming data. */
+    async delete(id, projectKey) {
+        const endpointId = encodeURIComponent(id);
+        await this.client.del(`/public/api/projects/${this.enc(projectKey)}/streamingendpoints/${endpointId}`);
+    }
+}

package/dist/src/resources/webapps.d.ts

@@ -0,0 +1,27 @@
+import { BaseResource } from "./base.js";
+export interface WebappListItem {
+    id?: string;
+    webAppId?: string;
+    name?: string;
+    type?: string;
+    projectKey?: string;
+}
+export interface WebappCreateResult {
+    webAppId: string;
+}
+export declare class WebappsResource extends BaseResource {
+    /** List all webapps in a project. */
+    list(projectKey?: string): Promise<WebappListItem[]>;
+    /** Get one webapp's settings. */
+    getSettings(webappId: string, projectKey?: string): Promise<Record<string, unknown>>;
+    /** Create a webapp. */
+    create(body: Record<string, unknown>, projectKey?: string): Promise<WebappCreateResult>;
+    /** Update one webapp's settings. */
+    updateSettings(webappId: string, body: Record<string, unknown>, projectKey?: string): Promise<Record<string, unknown>>;
+    /** Stop a webapp backend. */
+    stopBackend(webappId: string, projectKey?: string): Promise<void>;
+    /** Start or restart a webapp backend. */
+    startOrRestartBackend(webappId: string, projectKey?: string): Promise<void>;
+    /** Get a webapp backend's state. */
+    getBackendState(webappId: string, projectKey?: string): Promise<Record<string, unknown>>;
+}

package/dist/src/resources/webapps.js

@@ -0,0 +1,36 @@
+import { BaseResource, } from "./base.js";
+export class WebappsResource extends BaseResource {
+    /** List all webapps in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/webapps/`);
+    }
+    /** Get one webapp's settings. */
+    async getSettings(webappId, projectKey) {
+        const id = encodeURIComponent(webappId);
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/webapps/${id}`);
+    }
+    /** Create a webapp. */
+    async create(body, projectKey) {
+        return this.client.post(`/public/api/projects/${this.enc(projectKey)}/webapps/`, body);
+    }
+    /** Update one webapp's settings. */
+    async updateSettings(webappId, body, projectKey) {
+        const id = encodeURIComponent(webappId);
+        return this.client.put(`/public/api/projects/${this.enc(projectKey)}/webapps/${id}`, body);
+    }
+    /** Stop a webapp backend. */
+    async stopBackend(webappId, projectKey) {
+        const id = encodeURIComponent(webappId);
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/webapps/${id}/backend/actions/stop`, {});
+    }
+    /** Start or restart a webapp backend. */
+    async startOrRestartBackend(webappId, projectKey) {
+        const id = encodeURIComponent(webappId);
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/webapps/${id}/backend/actions/restart`, {});
+    }
+    /** Get a webapp backend's state. */
+    async getBackendState(webappId, projectKey) {
+        const id = encodeURIComponent(webappId);
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/webapps/${id}/backend/state`);
+    }
+}

package/dist/src/resources/workspaces.d.ts

@@ -0,0 +1,59 @@
+import { BaseResource } from "./base.js";
+export type WorkspaceObjectReferenceType = "DATASET" | "ARTICLE" | "DASHBOARD" | (string & {});
+export interface WorkspacePermissionItem extends Record<string, unknown> {
+    group?: string;
+    user?: string;
+    admin?: boolean;
+    write?: boolean;
+    read?: boolean;
+}
+export interface WorkspaceListItem extends Record<string, unknown> {
+    workspaceKey?: string;
+    displayName?: string;
+    color?: string | null;
+    description?: string | null;
+}
+export interface WorkspaceSettings extends WorkspaceListItem {
+    permissions?: WorkspacePermissionItem[] | null;
+}
+export interface WorkspaceCreateRequest extends Record<string, unknown> {
+    workspaceKey: string;
+    displayName: string;
+    color?: string | null;
+    description?: string | null;
+    permissions?: WorkspacePermissionItem[] | null;
+}
+export interface WorkspaceObjectReference extends Record<string, unknown> {
+    projectKey?: string;
+    type?: WorkspaceObjectReferenceType;
+    id?: string;
+    workspaceKey?: string;
+}
+export interface WorkspaceHtmlLinkObject extends Record<string, unknown> {
+    name: string;
+    url: string;
+    description?: string | null;
+}
+export interface WorkspaceObject extends Record<string, unknown> {
+    id?: string;
+    reference?: WorkspaceObjectReference;
+    appId?: string;
+    htmlLink?: WorkspaceHtmlLinkObject;
+}
+export type WorkspaceObjectInput = WorkspaceObject;
+export declare class WorkspacesResource extends BaseResource {
+    /** List workspaces visible to the API key. */
+    list(): Promise<WorkspaceListItem[]>;
+    /** Get workspace settings. */
+    get(workspaceKey: string): Promise<WorkspaceSettings>;
+    /** Create a workspace. DSS returns a text confirmation. */
+    create(body: WorkspaceCreateRequest): Promise<string>;
+    /** Replace workspace settings. */
+    updateSettings(workspaceKey: string, body: WorkspaceSettings): Promise<void>;
+    /** Delete a workspace. */
+    delete(workspaceKey: string): Promise<void>;
+    /** List objects in a workspace. */
+    listObjects(workspaceKey: string): Promise<WorkspaceObject[]>;
+    /** Add an object to a workspace. */
+    addObject(workspaceKey: string, object: WorkspaceObjectInput): Promise<WorkspaceObject>;
+}