dataiku-sdk 0.1.0

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

@@ -0,0 +1,20 @@
+import type { ConnectionSummary } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export declare class ConnectionsResource extends BaseResource {
+    /**
+     * Returns sorted list of all connection names visible to the current user.
+     */
+    list(): Promise<string[]>;
+    /**
+     * Infers available connections.
+     *
+     * - fast (default): fetches the connection name list and maps to ConnectionSummary.
+     *   Falls back to rich mode on any failure.
+     * - rich: inspects project datasets to derive connection metadata
+     *   (types, managed flag, db schemas).
+     */
+    infer(opts?: {
+        mode?: "fast" | "rich";
+        projectKey?: string;
+    }): Promise<ConnectionSummary[]>;
+}

package/dist/src/resources/connections.js

@@ -0,0 +1,77 @@
+import { BaseResource, } from "./base.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function normalizeConnectionNames(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((v) => typeof v === "string" && v.length > 0)
+        .sort();
+}
+async function inferRichConnectionsFromDatasets(client, projectEnc) {
+    const datasets = await client.get(`/public/api/projects/${projectEnc}/datasets/`);
+    const map = new Map();
+    for (const ds of datasets) {
+        const d = ds;
+        const params = d["params"];
+        const connection = params?.["connection"];
+        if (typeof connection !== "string" || connection.length === 0)
+            continue;
+        if (!map.has(connection)) {
+            map.set(connection, { types: new Set(), managed: false, dbSchemas: new Set(), });
+        }
+        const entry = map.get(connection);
+        const dsType = d["type"];
+        if (typeof dsType === "string" && dsType.length > 0)
+            entry.types.add(dsType);
+        if (d["managed"] === true)
+            entry.managed = true;
+        const schema = params?.["schema"];
+        if (typeof schema === "string" && schema.length > 0)
+            entry.dbSchemas.add(schema);
+    }
+    return [...map.entries(),]
+        .sort(([a,], [b,]) => a.localeCompare(b))
+        .map(([name, { types, managed, dbSchemas, },]) => ({
+        name,
+        types: [...types,].sort(),
+        managed,
+        dbSchemas: [...dbSchemas,].sort(),
+    }));
+}
+// ---------------------------------------------------------------------------
+// Resource
+// ---------------------------------------------------------------------------
+export class ConnectionsResource extends BaseResource {
+    /**
+     * Returns sorted list of all connection names visible to the current user.
+     */
+    async list() {
+        const raw = await this.client.get(`/public/api/connections/get-names/`);
+        return normalizeConnectionNames(raw);
+    }
+    /**
+     * Infers available connections.
+     *
+     * - fast (default): fetches the connection name list and maps to ConnectionSummary.
+     *   Falls back to rich mode on any failure.
+     * - rich: inspects project datasets to derive connection metadata
+     *   (types, managed flag, db schemas).
+     */
+    async infer(opts) {
+        const mode = opts?.mode ?? "fast";
+        const projectEnc = this.enc(opts?.projectKey);
+        if (mode === "rich") {
+            return inferRichConnectionsFromDatasets(this.client, projectEnc);
+        }
+        // fast — attempt name list, fall back to rich on any error
+        try {
+            const names = await this.list();
+            return names.map((name) => ({ name, }));
+        }
+        catch {
+            return inferRichConnectionsFromDatasets(this.client, projectEnc);
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+import { BaseResource } from "./base.js";
+import type { DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary } from "../schemas.js";
+/**
+ * Compare streamed TSV header columns against a known dataset schema.
+ * Returns an array of warning strings (empty if all columns match).
+ */
+export declare function validateStreamColumns(headerRow: string[], expectedColumns: {
+    name: string;
+}[]): string[];
+export declare class DatasetsResource extends BaseResource {
+    /** List all datasets in a project. */
+    list(projectKey?: string): Promise<DatasetSummary[]>;
+    /** Get full dataset details. */
+    get(datasetName: string, projectKey?: string): Promise<DatasetDetails>;
+    /** Get dataset schema (column names and types). */
+    schema(datasetName: string, projectKey?: string): Promise<DatasetSchema>;
+    /**
+     * Preview dataset data as CSV text.
+     * Streams TSV from the API, converts to CSV, and returns up to `maxRows`
+     * data rows (plus header).
+     *
+     * If `validateColumns` is provided, the first TSV row (header) is checked
+     * against the column names. Mismatches emit a warning via onValidationWarning.
+     */
+    preview(datasetName: string, opts?: {
+        maxRows?: number;
+        projectKey?: string;
+        validateColumns?: {
+            name: string;
+        }[];
+    }): Promise<string>;
+    /** Get dataset metadata (tags, custom fields, checklists). */
+    metadata(datasetName: string, projectKey?: string): Promise<Record<string, unknown>>;
+    /**
+     * Download dataset data as a gzipped CSV file.
+     * Returns the absolute path of the written file.
+     */
+    download(datasetName: string, opts?: {
+        outputPath?: string;
+        projectKey?: string;
+        validateColumns?: {
+            name: string;
+        }[];
+    }): Promise<string>;
+    /**
+     * Create a new dataset.
+     *
+     * If `dsType` is not provided, a default is inferred from whether `table`
+     * is specified. On failure, the method retries once using a type inferred
+     * from existing datasets on the same connection.
+     */
+    create(opts: DatasetCreateOptions): Promise<Record<string, unknown>>;
+    /** Update a dataset by deep-merging a patch into the current definition. */
+    update(datasetName: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /** Delete a dataset. */
+    delete(datasetName: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/datasets.js

@@ -0,0 +1,423 @@
+import { createWriteStream, } from "node:fs";
+import { resolve, } from "node:path";
+import { Readable, Transform, } from "node:stream";
+import { pipeline, } from "node:stream/promises";
+import { createGzip, } from "node:zlib";
+import { DataikuError, } from "../errors.js";
+import { DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
+import { sanitizeFileName, } from "../utils/sanitize.js";
+import { BaseResource, } from "./base.js";
+// ---------------------------------------------------------------------------
+// Helpers: TSV → CSV streaming conversion
+// ---------------------------------------------------------------------------
+function csvEscape(field) {
+    if (field.includes(",")
+        || field.includes('"')
+        || field.includes("\n")
+        || field.includes("\r")
+        || field.includes("\t")) {
+        return `"${field.replace(/"/g, '""')}"`;
+    }
+    return field;
+}
+function createTsvStreamState() {
+    return {
+        currentField: "",
+        currentRow: [],
+        inQuotes: false,
+        pendingQuoteInQuotes: false,
+    };
+}
+function consumeTsvChunk(text, state, onRow) {
+    let i = 0;
+    if (state.pendingQuoteInQuotes) {
+        state.pendingQuoteInQuotes = false;
+        const first = text[0];
+        if (first === '"') {
+            state.currentField += '"';
+            i = 1;
+        }
+        else if (first === "\t" || first === "\n" || first === "\r") {
+            state.inQuotes = false;
+        }
+        else if (first !== undefined) {
+            // Ambiguous terminal quote from previous chunk; keep it as data.
+            state.currentField += '"';
+        }
+    }
+    for (; i < text.length; i++) {
+        const ch = text[i];
+        if (state.inQuotes) {
+            if (ch === '"') {
+                const next = text[i + 1];
+                if (next === '"') {
+                    state.currentField += '"';
+                    i++;
+                    continue;
+                }
+                if (next === undefined) {
+                    state.pendingQuoteInQuotes = true;
+                    continue;
+                }
+                if (next === "\t" || next === "\n" || next === "\r") {
+                    state.inQuotes = false;
+                    continue;
+                }
+                // Quote in the middle of quoted field text — keep it literal.
+                state.currentField += '"';
+                continue;
+            }
+            state.currentField += ch;
+            continue;
+        }
+        if (ch === '"' && state.currentField.length === 0) {
+            state.inQuotes = true;
+            continue;
+        }
+        if (ch === "\t") {
+            state.currentRow.push(state.currentField);
+            state.currentField = "";
+            continue;
+        }
+        if (ch === "\n") {
+            state.currentRow.push(state.currentField);
+            state.currentField = "";
+            const row = state.currentRow;
+            state.currentRow = [];
+            onRow(row);
+            continue;
+        }
+        if (ch === "\r") {
+            continue;
+        }
+        state.currentField += ch;
+    }
+}
+function flushTsvStream(state, onRow) {
+    if (state.pendingQuoteInQuotes) {
+        state.currentField += '"';
+        state.pendingQuoteInQuotes = false;
+    }
+    if (state.currentField.length === 0 && state.currentRow.length === 0)
+        return;
+    state.currentRow.push(state.currentField);
+    state.currentField = "";
+    const row = state.currentRow;
+    state.currentRow = [];
+    onRow(row);
+}
+function rowToCsv(row) {
+    return row.map((field) => csvEscape(field)).join(",");
+}
+function isBlankRow(row) {
+    return row.length === 1 && row[0].length === 0;
+}
+/**
+ * Compare streamed TSV header columns against a known dataset schema.
+ * Returns an array of warning strings (empty if all columns match).
+ */
+export function validateStreamColumns(headerRow, expectedColumns) {
+    const warnings = [];
+    const headerSet = new Set(headerRow);
+    const expectedSet = new Set(expectedColumns.map((c) => c.name));
+    for (const col of expectedColumns) {
+        if (!headerSet.has(col.name)) {
+            warnings.push(`Missing expected column: "${col.name}"`);
+        }
+    }
+    for (const col of headerRow) {
+        if (!expectedSet.has(col)) {
+            warnings.push(`Unexpected column in stream: "${col}"`);
+        }
+    }
+    return warnings;
+}
+function emitCsvLineWithLimit(row, maxDataRows, emittedRows, onLine, onHeader) {
+    if (isBlankRow(row))
+        return false;
+    const isHeader = emittedRows.value === 0;
+    if (isHeader && onHeader)
+        onHeader(row);
+    if (!isHeader && emittedRows.value - 1 >= maxDataRows) {
+        return true;
+    }
+    onLine(rowToCsv(row));
+    emittedRows.value += 1;
+    if (!isHeader && emittedRows.value - 1 >= maxDataRows) {
+        return true;
+    }
+    return false;
+}
+async function collectPreviewCsv(body, maxDataRows, onHeader) {
+    const state = createTsvStreamState();
+    const emittedRows = { value: 0, };
+    const lines = [];
+    let done = false;
+    const nodeStream = Readable.fromWeb(body);
+    for await (const chunk of nodeStream) {
+        if (done)
+            break;
+        consumeTsvChunk(Buffer.from(chunk).toString("utf-8"), state, (row) => {
+            if (done)
+                return;
+            done = emitCsvLineWithLimit(row, maxDataRows, emittedRows, (line) => {
+                lines.push(line);
+            }, onHeader);
+        });
+        if (done) {
+            nodeStream.destroy();
+            break;
+        }
+    }
+    if (!done) {
+        flushTsvStream(state, (row) => {
+            if (done)
+                return;
+            done = emitCsvLineWithLimit(row, maxDataRows, emittedRows, (line) => {
+                lines.push(line);
+            }, onHeader);
+        });
+    }
+    return lines.join("\n");
+}
+function tsvToCsvTransform(maxDataRows, onHeader) {
+    const state = createTsvStreamState();
+    const emittedRows = { value: 0, };
+    let done = false;
+    const maxRows = Math.max(1, maxDataRows);
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            if (done) {
+                callback();
+                return;
+            }
+            consumeTsvChunk(chunk.toString("utf-8"), state, (row) => {
+                if (done)
+                    return;
+                done = emitCsvLineWithLimit(row, maxRows, emittedRows, (line) => {
+                    this.push(`${line}\n`);
+                }, onHeader);
+            });
+            if (done) {
+                this.push(null);
+            }
+            callback();
+        },
+        flush(callback) {
+            if (done) {
+                callback();
+                return;
+            }
+            flushTsvStream(state, (row) => {
+                if (done)
+                    return;
+                done = emitCsvLineWithLimit(row, maxRows, emittedRows, (line) => {
+                    this.push(`${line}\n`);
+                }, onHeader);
+            });
+            callback();
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Helpers: dataset creation
+// ---------------------------------------------------------------------------
+const DEFAULT_DATABASE_DATASET_TYPE = "Snowflake";
+const DEFAULT_FILESYSTEM_DATASET_TYPE = "Filesystem";
+function shouldRetryWithConnectionInferredType(error) {
+    if (!(error instanceof DataikuError))
+        return false;
+    if (error.category !== "validation" && error.category !== "unknown")
+        return false;
+    const detail = `${error.statusText ?? ""}\n${error.body ?? ""}`.toLowerCase();
+    return (detail.includes("connection")
+        || detail.includes("dataset type")
+        || detail.includes("invalid type")
+        || detail.includes("illegal argument"));
+}
+function buildDatasetCreateBody(opts) {
+    if (opts.table) {
+        const params = {
+            connection: opts.connection,
+            mode: "table",
+            table: opts.table,
+        };
+        if (opts.dbSchema)
+            params.schema = opts.dbSchema;
+        if (opts.catalog)
+            params.catalog = opts.catalog;
+        return {
+            projectKey: opts.projectKey,
+            name: opts.datasetName,
+            type: opts.dsType,
+            params,
+            managed: opts.managed ?? false,
+        };
+    }
+    return {
+        projectKey: opts.projectKey,
+        name: opts.datasetName,
+        type: opts.dsType,
+        params: {
+            connection: opts.connection,
+            path: `${opts.projectKey}/${opts.datasetName}`,
+        },
+        formatType: opts.formatType ?? "csv",
+        formatParams: opts.formatParams ?? {
+            style: "excel",
+            charset: "utf8",
+            separator: "\t",
+            quoteChar: '"',
+            escapeChar: "\\",
+            dateSerializationFormat: "ISO",
+            arrayMapFormat: "json",
+            parseHeaderRow: true,
+            compress: "gz",
+        },
+        managed: opts.managed ?? true,
+    };
+}
+// ---------------------------------------------------------------------------
+// Resource
+// ---------------------------------------------------------------------------
+export class DatasetsResource extends BaseResource {
+    /** List all datasets in a project. */
+    async list(projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/`);
+        return this.client.safeParse(DatasetSummaryArraySchema, raw, "datasets.list");
+    }
+    /** Get full dataset details. */
+    async get(datasetName, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}`);
+        return this.client.safeParse(DatasetDetailsSchema, raw, "datasets.get");
+    }
+    /** Get dataset schema (column names and types). */
+    async schema(datasetName, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`);
+        return this.client.safeParse(DatasetSchemaSchema, raw, "datasets.schema");
+    }
+    /**
+     * Preview dataset data as CSV text.
+     * Streams TSV from the API, converts to CSV, and returns up to `maxRows`
+     * data rows (plus header).
+     *
+     * If `validateColumns` is provided, the first TSV row (header) is checked
+     * against the column names. Mismatches emit a warning via onValidationWarning.
+     */
+    async preview(datasetName, opts) {
+        const maxRows = Math.max(1, Math.min(opts?.maxRows ?? 50, 500));
+        const dsEnc = encodeURIComponent(datasetName);
+        const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/datasets/${dsEnc}/data/?format=tsv-excel-header&limit=${maxRows}`);
+        const onHeader = opts?.validateColumns
+            ? (headerRow) => {
+                const warnings = validateStreamColumns(headerRow, opts.validateColumns);
+                if (warnings.length > 0) {
+                    this.client.warn(`datasets.preview(${datasetName})`, warnings);
+                }
+            }
+            : undefined;
+        return collectPreviewCsv(res.body, maxRows, onHeader);
+    }
+    /** Get dataset metadata (tags, custom fields, checklists). */
+    async metadata(datasetName, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/metadata`);
+    }
+    /**
+     * Download dataset data as a gzipped CSV file.
+     * Returns the absolute path of the written file.
+     */
+    async download(datasetName, opts) {
+        const downloadLimit = 100_000;
+        const dsEnc = encodeURIComponent(datasetName);
+        const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/datasets/${dsEnc}/data/?format=tsv-excel-header&limit=${downloadLimit}`);
+        const safeDatasetName = sanitizeFileName(datasetName, "dataset");
+        const filePath = opts?.outputPath?.endsWith(".gz") || opts?.outputPath?.endsWith(".csv")
+            ? resolve(opts.outputPath)
+            : resolve(opts?.outputPath ?? process.cwd(), `${safeDatasetName}.csv.gz`);
+        const onHeader = opts?.validateColumns
+            ? (headerRow) => {
+                const warnings = validateStreamColumns(headerRow, opts.validateColumns);
+                if (warnings.length > 0) {
+                    this.client.warn(`datasets.download(${datasetName})`, warnings);
+                }
+            }
+            : undefined;
+        const nodeStream = Readable.fromWeb(res.body);
+        const csvTransform = tsvToCsvTransform(downloadLimit, onHeader);
+        const gzip = createGzip();
+        const fileOut = createWriteStream(filePath);
+        await pipeline(nodeStream, csvTransform, gzip, fileOut);
+        return filePath;
+    }
+    /**
+     * Create a new dataset.
+     *
+     * If `dsType` is not provided, a default is inferred from whether `table`
+     * is specified. On failure, the method retries once using a type inferred
+     * from existing datasets on the same connection.
+     */
+    async create(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const enc = encodeURIComponent(pk);
+        const explicitType = opts.dsType;
+        let dsType = explicitType
+            ?? (opts.table ? DEFAULT_DATABASE_DATASET_TYPE : DEFAULT_FILESYSTEM_DATASET_TYPE);
+        let body = buildDatasetCreateBody({
+            projectKey: pk,
+            datasetName: opts.datasetName,
+            connection: opts.connection,
+            dsType,
+            table: opts.table,
+            dbSchema: opts.dbSchema,
+            catalog: opts.catalog,
+            formatType: opts.formatType,
+            formatParams: opts.formatParams,
+            managed: opts.managed,
+        });
+        try {
+            return await this.client.post(`/public/api/projects/${enc}/datasets/`, body);
+        }
+        catch (error) {
+            if (explicitType || !shouldRetryWithConnectionInferredType(error)) {
+                throw error;
+            }
+            // Infer type from existing datasets on the same connection.
+            const existing = await this.client.get(`/public/api/projects/${enc}/datasets/`);
+            const inferredType = existing.find((d) => d.params?.connection === opts.connection && d.type)?.type;
+            if (!inferredType || inferredType === dsType) {
+                throw error;
+            }
+            dsType = inferredType;
+            body = buildDatasetCreateBody({
+                projectKey: pk,
+                datasetName: opts.datasetName,
+                connection: opts.connection,
+                dsType,
+                table: opts.table,
+                dbSchema: opts.dbSchema,
+                catalog: opts.catalog,
+                formatType: opts.formatType,
+                formatParams: opts.formatParams,
+                managed: opts.managed,
+            });
+            return this.client.post(`/public/api/projects/${enc}/datasets/`, body);
+        }
+    }
+    /** Update a dataset by deep-merging a patch into the current definition. */
+    async update(datasetName, data, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        const pkEnc = this.enc(projectKey);
+        const current = await this.client.get(`/public/api/projects/${pkEnc}/datasets/${dsEnc}`);
+        const merged = deepMerge(current, data);
+        await this.client.put(`/public/api/projects/${pkEnc}/datasets/${dsEnc}`, merged);
+    }
+    /** Delete a dataset. */
+    async delete(datasetName, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        await this.client.del(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}`);
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { FolderDetails, FolderItem, FolderSummary } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export declare class FoldersResource extends BaseResource {
+    list(projectKey?: string): Promise<FolderSummary[]>;
+    get(folderId: string, projectKey?: string): Promise<FolderDetails>;
+    contents(folderId: string, opts?: {
+        projectKey?: string;
+    }): Promise<FolderItem[]>;
+    download(folderId: string, path: string, opts?: {
+        localPath?: string;
+        projectKey?: string;
+    }): Promise<string>;
+    upload(folderId: string, path: string, localPath: string, projectKey?: string): Promise<void>;
+    deleteFile(folderId: string, path: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/folders.js

@@ -0,0 +1,58 @@
+import { createWriteStream, } from "node:fs";
+import { resolve, } from "node:path";
+import { Readable, } from "node:stream";
+import { pipeline, } from "node:stream/promises";
+import { FolderDetailsSchema, FolderItemArraySchema, FolderSummaryArraySchema, } from "../schemas.js";
+import { sanitizeFileName, } from "../utils/sanitize.js";
+import { BaseResource, } from "./base.js";
+function normalizeRemotePath(path) {
+    return path.replace(/\\/g, "/");
+}
+function inferDownloadFileName(remotePath) {
+    const segments = remotePath.split("/").filter(Boolean);
+    const last = segments[segments.length - 1] ?? "file";
+    return sanitizeFileName(last, "file");
+}
+// ---------------------------------------------------------------------------
+// Resource
+// ---------------------------------------------------------------------------
+export class FoldersResource extends BaseResource {
+    async list(projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/managedfolders/`);
+        return this.client.safeParse(FolderSummaryArraySchema, raw, "folders.list");
+    }
+    async get(folderId, projectKey) {
+        const fEnc = encodeURIComponent(folderId);
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/managedfolders/${fEnc}`);
+        return this.client.safeParse(FolderDetailsSchema, raw, "folders.get");
+    }
+    async contents(folderId, opts) {
+        const fEnc = encodeURIComponent(folderId);
+        const response = await this.client.get(`/public/api/projects/${this.enc(opts?.projectKey)}/managedfolders/${fEnc}/contents/`);
+        const items = response.items ?? [];
+        return this.client.safeParse(FolderItemArraySchema, items, "folders.contents");
+    }
+    async download(folderId, path, opts) {
+        const fEnc = encodeURIComponent(folderId);
+        const normalizedPath = normalizeRemotePath(path);
+        const pEnc = encodeURIComponent(normalizedPath);
+        const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/managedfolders/${fEnc}/contents/${pEnc}`);
+        const dest = opts?.localPath ?? resolve(process.cwd(), inferDownloadFileName(normalizedPath));
+        const nodeStream = Readable.fromWeb(res.body);
+        const fileOut = createWriteStream(dest);
+        await pipeline(nodeStream, fileOut);
+        return dest;
+    }
+    upload(folderId, path, localPath, projectKey) {
+        const fEnc = encodeURIComponent(folderId);
+        const normalizedPath = normalizeRemotePath(path);
+        const pEnc = encodeURIComponent(normalizedPath);
+        return this.client.upload(`/public/api/projects/${this.enc(projectKey)}/managedfolders/${fEnc}/contents/${pEnc}`, localPath);
+    }
+    deleteFile(folderId, path, projectKey) {
+        const fEnc = encodeURIComponent(folderId);
+        const normalizedPath = normalizeRemotePath(path);
+        const pEnc = encodeURIComponent(normalizedPath);
+        return this.client.del(`/public/api/projects/${this.enc(projectKey)}/managedfolders/${fEnc}/contents/${pEnc}`);
+    }
+}