dataiku-sdk 0.12.7 → 1.1.0

package/dist/src/resources/datasets.js

@@ -3,11 +3,12 @@ import * as nodePath 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 { ClientValidationError, 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";
+import { resolveAdminManagedStorageConnection, } from "./connections.js";
 // ---------------------------------------------------------------------------
 // Helpers: TSV → CSV streaming conversion
 // ---------------------------------------------------------------------------
@@ -133,46 +134,52 @@ export function validateStreamColumns(headerRow, expectedColumns) {
     }
     return warnings;
 }
-function buildPreviewTimeoutError(timeoutMs) {
-    return new DataikuError(0, "Request Timeout", `Dataset preview timed out after ${timeoutMs}ms while waiting for rows.`);
+function buildStreamTimeoutError(timeoutMs, action) {
+    return new DataikuError(0, "Request Timeout", `Dataset ${action} timed out after ${timeoutMs}ms while waiting for rows.`);
 }
-async function readChunkWithTimeout(reader, remainingMs, timeoutMs) {
-    return new Promise((resolveChunk, rejectChunk) => {
-        const timer = setTimeout(() => {
-            void reader.cancel(buildPreviewTimeoutError(timeoutMs)).catch(() => { });
-            rejectChunk(buildPreviewTimeoutError(timeoutMs));
-        }, remainingMs);
-        reader.read().then((result) => {
-            clearTimeout(timer);
-            resolveChunk(result);
-        }, (error) => {
-            clearTimeout(timer);
-            rejectChunk(error);
-        });
+async function readChunkWithTimeout(reader, remainingMs, timeoutMs, action) {
+    const { promise, resolve, reject, } = Promise.withResolvers();
+    const timer = setTimeout(() => {
+        void reader.cancel(buildStreamTimeoutError(timeoutMs, action)).catch(() => { });
+        reject(buildStreamTimeoutError(timeoutMs, action));
+    }, remainingMs);
+    reader.read().then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+    }, (error) => {
+        clearTimeout(timer);
+        reject(error);
     });
+    return promise;
 }
 async function collectPreviewRows(body, maxDataRows, timeoutMs, onHeader) {
     const state = createTsvStreamState();
     let columns;
     const rows = [];
     let done = false;
+    let truncated = false;
     const startedAt = Date.now();
     const reader = body.getReader();
+    let columnCount = 0;
     const handleRow = (row) => {
-        if (done || isBlankRow(row))
+        if (done)
             return;
         if (columns === undefined) {
+            if (isBlankRow(row))
+                return;
             columns = row;
+            columnCount = row.length;
             onHeader?.(row);
             return;
         }
+        if (isBlankRow(row) && columnCount !== 1)
+            return;
         if (rows.length >= maxDataRows) {
+            truncated = true;
             done = true;
             return;
         }
         rows.push(row);
-        if (rows.length >= maxDataRows)
-            done = true;
     };
     try {
         while (true) {
@@ -182,15 +189,73 @@ async function collectPreviewRows(body, maxDataRows, timeoutMs, onHeader) {
             }
             const remainingMs = timeoutMs - (Date.now() - startedAt);
             if (remainingMs <= 0)
-                throw buildPreviewTimeoutError(timeoutMs);
-            const result = await readChunkWithTimeout(reader, remainingMs, timeoutMs);
+                throw buildStreamTimeoutError(timeoutMs, "preview");
+            const result = await readChunkWithTimeout(reader, remainingMs, timeoutMs, "preview");
             if (result.done)
                 break;
             consumeTsvChunk(Buffer.from(result.value).toString("utf-8"), state, handleRow);
         }
         if (!done)
             flushTsvStream(state, handleRow);
-        return { columns: columns ?? [], rows, };
+        return { columns: columns ?? [], rows, truncated, };
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/**
+ * Count data rows in a streamed TSV response (header row excluded), stopping
+ * as soon as `stopAfter` rows have been seen so a mismatched dataset is never
+ * fully scanned. Returns the exact count when the stream ends before the cap,
+ * or `stopAfter` — a lower bound — once the cap is reached.
+ */
+async function collectTsvRowCount(body, stopAfter, timeoutMs) {
+    const state = createTsvStreamState();
+    let headerSeen = false;
+    let count = 0;
+    let bounded = false;
+    const startedAt = Date.now();
+    const reader = body.getReader();
+    let columnCount = 0;
+    const handleRow = (row) => {
+        if (bounded)
+            return;
+        if (!headerSeen) {
+            if (isBlankRow(row))
+                return;
+            headerSeen = true;
+            columnCount = row.length;
+            return;
+        }
+        // An empty line is structurally invalid in a multi-column TSV (blank
+        // rows are tolerated and skipped), but for single-column datasets an
+        // empty line is a real data row carrying an empty string value and
+        // must be counted. The stream parser only emits rows for real line
+        // terminators, so the synthetic trailing newline never produces one.
+        if (isBlankRow(row) && columnCount !== 1)
+            return;
+        count += 1;
+        if (count >= stopAfter)
+            bounded = true;
+    };
+    try {
+        while (true) {
+            if (bounded) {
+                void reader.cancel().catch(() => { });
+                break;
+            }
+            const remainingMs = timeoutMs - (Date.now() - startedAt);
+            if (remainingMs <= 0) {
+                throw buildStreamTimeoutError(timeoutMs, "row count assertion");
+            }
+            const result = await readChunkWithTimeout(reader, remainingMs, timeoutMs, "row count assertion");
+            if (result.done)
+                break;
+            consumeTsvChunk(Buffer.from(result.value).toString("utf-8"), state, handleRow);
+        }
+        if (!bounded)
+            flushTsvStream(state, handleRow);
+        return { count, bounded, };
     }
     finally {
         reader.releaseLock();
@@ -201,15 +266,21 @@ function tsvToCsvTransform(maxDataRows, stats, onHeader) {
     const maxRows = Math.max(1, maxDataRows);
     let headerSeen = false;
     let done = false;
+    let columnCount = 0;
     const handleRow = (row, push) => {
-        if (done || isBlankRow(row))
+        if (done)
             return;
         if (!headerSeen) {
+            if (isBlankRow(row))
+                return;
             headerSeen = true;
+            columnCount = row.length;
             onHeader?.(row);
             push(`${rowToCsv(row)}\n`);
             return;
         }
+        if (isBlankRow(row) && columnCount !== 1)
+            return;
         if (stats.rows >= maxRows) {
             stats.truncated = true;
             done = true;
@@ -253,15 +324,25 @@ function shouldRetryWithConnectionInferredType(error) {
         || detail.includes("invalid type")
         || detail.includes("illegal argument"));
 }
+function isMissingUploadedFilesTargetConnection(error) {
+    if (!(error instanceof DataikuError))
+        return false;
+    const detail = error.body.toLowerCase();
+    return (detail.includes("without a target connection")
+        || detail.includes("target connection is required"));
+}
 function buildDatasetCreateBody(opts) {
     if (opts.dsType.toLowerCase() === "uploadedfiles") {
         return {
             projectKey: opts.projectKey,
             name: opts.datasetName,
             type: opts.dsType,
-            params: { uploadConnection: opts.connection, },
+            params: opts.connection ? { uploadConnection: opts.connection, } : {},
         };
     }
+    if (!opts.connection) {
+        throw new ClientValidationError("connection is required unless dsType is UploadedFiles.");
+    }
     if (opts.table) {
         const params = {
             connection: opts.connection,
@@ -326,6 +407,21 @@ function cloneDatasetParams(params) {
     }
     return cloned;
 }
+function parseUploadedFiles(raw, datasetName) {
+    if (!Array.isArray(raw)) {
+        throw new ClientValidationError(`DSS returned an invalid uploaded-files list for dataset ${datasetName}.`, "validation_failed", "Expected an array from the UploadedFiles dataset file endpoint.");
+    }
+    return raw.map((item, index) => {
+        if (!item
+            || typeof item !== "object"
+            || Array.isArray(item)
+            || typeof item.filename !== "string"
+            || item.filename === "") {
+            throw new ClientValidationError(`DSS returned invalid metadata for uploaded file ${String(index)} in dataset ${datasetName}.`, "validation_failed", "Expected every uploaded file to include a non-empty filename.");
+        }
+        return item;
+    });
+}
 export function buildDatasetCloneSettings(source, targetName, projectKey, opts) {
     const params = {
         ...cloneDatasetParams(source.params),
@@ -384,6 +480,14 @@ export class DatasetsResource extends BaseResource {
         const dsEnc = encodeURIComponent(datasetName);
         await this.client.put(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`, { columns, });
     }
+    /**
+     * Get the raw dataset schema object exactly as the DSS schema endpoint
+     * returns it, without schema validation — used for deterministic comparison.
+     */
+    async getSchemaObject(datasetName, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`);
+    }
     /**
      * Preview dataset rows as structured data: column names plus row arrays,
      * mirroring the sql query shape ({ columns, rows, rowCount }). Streams TSV
@@ -396,7 +500,9 @@ export class DatasetsResource extends BaseResource {
         const maxRows = Math.max(1, Math.min(opts?.maxRows ?? 50, 500));
         const timeoutMs = Math.max(1, opts?.timeoutMs ?? this.client.getRequestTimeoutMs());
         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}`);
+        // Probe one row past the cap so callers learn whether the dataset holds
+        // more rows than requested without materializing the full dataset.
+        const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/datasets/${dsEnc}/data/?format=tsv-excel-header&limit=${maxRows + 1}`);
         const onHeader = opts?.validateColumns
             ? (headerRow) => {
                 const warnings = validateStreamColumns(headerRow, opts.validateColumns);
@@ -405,10 +511,39 @@ export class DatasetsResource extends BaseResource {
                 }
             }
             : undefined;
-        if (!res.body)
-            return { columns: [], rows: [], rowCount: 0, };
-        const { columns, rows, } = await collectPreviewRows(res.body, maxRows, timeoutMs, onHeader);
-        return { columns: columns.map((name) => ({ name, })), rows, rowCount: rows.length, };
+        if (!res.body) {
+            return { columns: [], rows: [], rowCount: 0, truncated: false, limit: maxRows, };
+        }
+        const { columns, rows, truncated, } = await collectPreviewRows(res.body, maxRows, timeoutMs, onHeader);
+        return {
+            columns: columns.map((name) => ({ name, })),
+            rows,
+            rowCount: rows.length,
+            truncated,
+            limit: maxRows,
+        };
+    }
+    /**
+     * Count dataset rows by streaming the TSV data endpoint and stopping as soon
+     * as `expected + 1` rows have been seen, so a mismatched dataset is never
+     * fully scanned. Returns the observed count together with `exact` (false when
+     * the probe cap was reached, i.e. the count is a lower bound) and whether the
+     * count satisfies the assertion.
+     */
+    async assertRowCount(datasetName, expected, projectKey) {
+        if (!Number.isSafeInteger(expected) || expected < 0) {
+            throw new ClientValidationError("expected row count must be a non-negative safe integer", "validation_failed");
+        }
+        const target = expected;
+        const probe = target + 1;
+        const timeoutMs = Math.max(1, this.client.getRequestTimeoutMs());
+        const dsEnc = encodeURIComponent(datasetName);
+        const res = await this.client.stream(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/data/?format=tsv-excel-header&limit=${probe}`);
+        if (!res.body) {
+            return { expected: target, count: 0, exact: true, satisfied: target === 0, };
+        }
+        const { count, bounded, } = await collectTsvRowCount(res.body, probe, timeoutMs);
+        return { expected: target, count, exact: !bounded, satisfied: !bounded && count === target, };
     }
     /** Get dataset metadata (tags, custom fields, checklists). */
     async metadata(datasetName, projectKey) {
@@ -481,6 +616,35 @@ export class DatasetsResource extends BaseResource {
             return await this.client.post(`/public/api/projects/${enc}/datasets/`, body);
         }
         catch (error) {
+            if (explicitType?.toLowerCase() === "uploadedfiles"
+                && !opts.connection
+                && isMissingUploadedFilesTargetConnection(error)) {
+                let uploadConnection = await resolveAdminManagedStorageConnection(this.client, "allowManagedDatasets", "filesystem_managed");
+                if (!uploadConnection) {
+                    const existing = await this.list(pk);
+                    uploadConnection = [
+                        ...new Set(existing
+                            .filter((dataset) => dataset.managed === true)
+                            .map((dataset) => dataset.params?.connection)
+                            .filter((connection) => typeof connection === "string" && connection.length > 0)),
+                    ].sort()[0];
+                }
+                if (!uploadConnection)
+                    throw error;
+                body = buildDatasetCreateBody({
+                    projectKey: pk,
+                    datasetName: opts.datasetName,
+                    connection: uploadConnection,
+                    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);
+            }
             if (explicitType || !shouldRetryWithConnectionInferredType(error)) {
                 throw error;
             }
@@ -519,6 +683,7 @@ export class DatasetsResource extends BaseResource {
             ? params.table
             : null;
         const normalizedType = (type ?? "").toLowerCase();
+        const uploadedFiles = normalizedType.includes("uploaded");
         const fileBacked = !table
             && (normalizedType.includes("filesystem")
                 || normalizedType.includes("uploaded")
@@ -526,7 +691,7 @@ export class DatasetsResource extends BaseResource {
                 || path !== null);
         const formatType = details.formatType ?? null;
         const warnings = [];
-        if (fileBacked && !path) {
+        if (fileBacked && !uploadedFiles && !path) {
             warnings.push("File-backed dataset has no writable storage path configured.");
         }
         if (fileBacked && !formatType) {
@@ -545,6 +710,52 @@ export class DatasetsResource extends BaseResource {
             note: "Validates build configuration only; it does not verify storage file existence or materialized data.",
         };
     }
+    /** List files stored by an UploadedFiles dataset. */
+    async listUploadedFiles(datasetName, projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${encodeURIComponent(datasetName)}/uploaded/files`);
+        return parseUploadedFiles(raw, datasetName);
+    }
+    /** Add a new file to an UploadedFiles dataset and verify its byte length. */
+    async uploadDatasetFile(datasetName, localPath, opts) {
+        const fileName = opts.fileName.trim();
+        if (fileName === "") {
+            throw new ClientValidationError("fileName must be a non-empty uploaded filename.");
+        }
+        const localFile = await fs.promises.stat(localPath);
+        if (!localFile.isFile()) {
+            throw new ClientValidationError(`${localPath} is not a regular file.`);
+        }
+        const projectKey = this.resolveProjectKey(opts.projectKey);
+        const details = await this.get(datasetName, projectKey);
+        if (details.type?.toLowerCase() !== "uploadedfiles") {
+            throw new ClientValidationError(`Dataset ${datasetName} is ${details.type ?? "an unknown type"}, not UploadedFiles.`, "validation_failed", "Use dataset upload-file only with an UploadedFiles dataset.");
+        }
+        const existing = (await this.listUploadedFiles(datasetName, projectKey))
+            .filter((file) => file.filename === fileName);
+        if (existing.length !== 0) {
+            throw new ClientValidationError(`Uploaded file ${fileName} already exists in dataset ${datasetName}.`, "validation_failed", "DSS 14.7's public API can add uploaded files but cannot replace or delete them. Use a new filename or import a successor project archive containing the replacement.");
+        }
+        const endpoint = `/public/api/projects/${encodeURIComponent(projectKey)}/datasets/${encodeURIComponent(datasetName)}/uploaded/files`;
+        await this.client.upload(endpoint, localPath, fileName);
+        const afterMatches = (await this.listUploadedFiles(datasetName, projectKey))
+            .filter((file) => file.filename === fileName);
+        const after = afterMatches[0];
+        if (afterMatches.length !== 1
+            || after === undefined
+            || after.length !== localFile.size) {
+            throw new ClientValidationError(`DSS did not verify upload of ${fileName} to dataset ${datasetName}.`, "ambiguous_outcome", "The upload returned successfully, but the uploaded-files listing did not show exactly one target with the local byte length. Inspect the dataset before retrying.", {
+                expectedBytes: localFile.size,
+                matchingFiles: afterMatches,
+            });
+        }
+        return {
+            datasetName,
+            projectKey,
+            fileName,
+            bytes: localFile.size,
+            after,
+        };
+    }
     /** Clone dataset settings, preserving connection/storage, format, and schema fields. */
     async clone(sourceName, targetName, opts = {}) {
         const pk = this.resolveProjectKey(opts.projectKey);

package/dist/src/resources/folders.js

@@ -6,6 +6,7 @@ import { FolderDetailsSchema, FolderItemArraySchema, FolderSummaryArraySchema, }
 import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
+import { resolveAdminManagedStorageConnection, } from "./connections.js";
 function normalizeRemotePath(path) {
     return path.replace(/\\/g, "/");
 }
@@ -20,14 +21,17 @@ function inferDownloadFileName(remotePath) {
 export class FoldersResource extends BaseResource {
     async create(opts) {
         const pk = this.resolveProjectKey(opts.projectKey);
-        const path = opts.path?.trim() || `/dataiku/${pk}/${opts.name}`;
+        const path = opts.path?.trim() || "/${projectKey}/${odbId}";
+        const connection = opts.connection
+            ?? await resolveAdminManagedStorageConnection(this.client, "allowManagedFolders", "filesystem_folders")
+            ?? "filesystem_folders";
         const raw = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/managedfolders/`, {
             name: opts.name,
             projectKey: pk,
-            type: opts.type,
+            type: opts.type ?? null,
             params: {
                 ...opts.params,
-                connection: opts.connection,
+                connection: connection,
                 path,
             },
         });

package/dist/src/resources/project-git.d.ts

@@ -0,0 +1,154 @@
+import type { ProjectGitActionResult, ProjectGitDiffResult, ProjectGitFutureResponse, ProjectGitFutureState, ProjectGitLibraries, ProjectGitLogResult, ProjectGitRemote, ProjectGitStatus, ProjectGitTags } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export interface ProjectGitSetRemoteOptions {
+    url: string;
+    name?: string;
+}
+export interface ProjectGitCreateBranchOptions {
+    commit?: string;
+    duplicateProject?: boolean;
+    targetProjectKey?: string;
+    targetProjectFolderId?: string;
+}
+export interface ProjectGitDeleteBranchOptions {
+    remote?: boolean;
+    deleteRemotely?: boolean;
+    forceDelete?: boolean;
+}
+export interface ProjectGitCreateTagOptions {
+    reference?: string;
+    message?: string;
+}
+export interface ProjectGitPullOptions {
+    branchName?: string;
+}
+export interface ProjectGitPushOptions {
+    branchName?: string;
+}
+export interface ProjectGitLogOptions {
+    path?: string;
+    startCommit?: string;
+    count?: number;
+}
+export interface ProjectGitDiffOptions {
+    commitFrom?: string;
+    commitTo?: string;
+}
+export interface ProjectGitCommitOptions {
+    message: string;
+}
+/**
+ * `dropAndRebuild` permanently destroys the project's Git history, so the
+ * caller must acknowledge it explicitly before the request is issued.
+ */
+export interface ProjectGitDropAndRebuildOptions {
+    confirmed?: boolean;
+}
+export interface ProjectGitAddLibraryOptions {
+    repository: string;
+    localTargetPath: string;
+    checkout: string;
+    pathInGitRepository?: string;
+    addToPythonPath?: boolean;
+    login?: string;
+    password?: string;
+}
+export interface ProjectGitSetLibraryOptions {
+    repository: string;
+    pathInGitRepository?: string;
+    checkout: string;
+    login?: string;
+    password?: string;
+}
+export interface ProjectGitFutureStateOptions {
+    peek?: boolean;
+}
+export interface ProjectGitFutureWaitOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+}
+export declare class ProjectGitResource extends BaseResource {
+    /** Working-copy status: current branch, remotes, tracking counts, changes. */
+    status(projectKey: string): Promise<ProjectGitStatus>;
+    /**
+     * Read a Git remote. DSS answers `{}` when the remote is not configured.
+     * The remote name defaults to `origin` like the Python client.
+     */
+    getRemote(projectKey: string, name?: string): Promise<ProjectGitRemote>;
+    /** Create or replace a Git remote. */
+    setRemote(projectKey: string, options: ProjectGitSetRemoteOptions): Promise<ProjectGitActionResult>;
+    /** Delete a Git remote. */
+    removeRemote(projectKey: string, name?: string): Promise<void>;
+    /** Plain list of branch names, local by default. */
+    listBranches(projectKey: string, remote?: boolean): Promise<string[]>;
+    /**
+     * Create a branch and switch to it. With `duplicateProject`, DSS creates a
+     * duplicate project for the branch instead of moving this one.
+     */
+    createBranch(projectKey: string, name: string, options?: ProjectGitCreateBranchOptions): Promise<ProjectGitActionResult>;
+    /** Delete a branch locally and, with `deleteRemotely`, on the remote too. */
+    deleteBranch(projectKey: string, name: string, options?: ProjectGitDeleteBranchOptions): Promise<ProjectGitActionResult>;
+    /** Current branch name, or null when DSS reports none. */
+    currentBranch(projectKey: string): Promise<string | null>;
+    /** Switch the project to another branch. */
+    switchBranch(projectKey: string, branchName: string): Promise<ProjectGitActionResult>;
+    listTags(projectKey: string): Promise<ProjectGitTags>;
+    createTag(projectKey: string, name: string, options?: ProjectGitCreateTagOptions): Promise<ProjectGitActionResult>;
+    deleteTag(projectKey: string, name: string): Promise<ProjectGitActionResult>;
+    /** Fetch from the remote. Failures arrive as `{success: false}` with HTTP 200. */
+    fetch(projectKey: string): Promise<ProjectGitActionResult>;
+    /** Pull. DSS only ever exposes a rebase pull; there is no merge variant. */
+    pull(projectKey: string, options?: ProjectGitPullOptions): Promise<ProjectGitActionResult>;
+    push(projectKey: string, options?: ProjectGitPushOptions): Promise<ProjectGitActionResult>;
+    /** Commit log page. Paginate by passing the previous `nextCommit` as `startCommit`. */
+    log(projectKey: string, options?: ProjectGitLogOptions): Promise<ProjectGitLogResult>;
+    diff(projectKey: string, options?: ProjectGitDiffOptions): Promise<ProjectGitDiffResult>;
+    /** Commit the project. DSS stages untracked files before committing. */
+    commit(projectKey: string, options: ProjectGitCommitOptions): Promise<ProjectGitActionResult>;
+    /** Restore the project to the state of a past commit. */
+    revertToRevision(projectKey: string, commit: string): Promise<ProjectGitActionResult>;
+    /** Revert one commit, keeping later history. */
+    revertCommit(projectKey: string, commit: string): Promise<ProjectGitActionResult>;
+    /** Hard reset to local HEAD, dropping uncommitted changes. */
+    resetToHead(projectKey: string): Promise<ProjectGitActionResult>;
+    /** Hard reset to the tracked upstream branch, dropping local commits. */
+    resetToUpstream(projectKey: string): Promise<ProjectGitActionResult>;
+    /**
+     * Wipe the project's entire Git history and rebuild a fresh repository.
+     * Irreversible, so nothing is sent unless the caller acknowledges it.
+     */
+    dropAndRebuild(projectKey: string, options?: ProjectGitDropAndRebuildOptions): Promise<ProjectGitActionResult>;
+    listLibraries(projectKey: string): Promise<ProjectGitLibraries>;
+    /** Attach an external Git library. Runs as a DSS future. */
+    addLibrary(projectKey: string, options: ProjectGitAddLibraryOptions): Promise<ProjectGitFutureResponse>;
+    /** Update an attached library's repository, sub-path, or checkout. */
+    setLibrary(projectKey: string, gitReferencePath: string, options: ProjectGitSetLibraryOptions): Promise<string>;
+    /** Detach a library, optionally deleting its local directory. */
+    removeLibrary(projectKey: string, gitReferencePath: string, deleteDirectory?: boolean): Promise<void>;
+    /** Reset one library to its remote state. Runs as a DSS future. */
+    resetLibrary(projectKey: string, gitReferencePath: string): Promise<ProjectGitFutureResponse>;
+    /** Commit and push one library. Runs as a DSS future. */
+    pushLibrary(projectKey: string, gitReferencePath: string, commitMessage: string): Promise<ProjectGitFutureResponse>;
+    /** Commit and push every attached library. Runs as a DSS future. */
+    pushAllLibraries(projectKey: string, commitMessage: string): Promise<ProjectGitFutureResponse>;
+    /** Reset every attached library to its remote state. Runs as a DSS future. */
+    resetAllLibraries(projectKey: string): Promise<ProjectGitFutureResponse>;
+    /**
+     * Read a future's state. `peek` leaves the future's log unconsumed, which is
+     * what polling loops want; the default consumes it like the Python client.
+     */
+    getFutureState(jobId: string, options?: ProjectGitFutureStateOptions): Promise<ProjectGitFutureState>;
+    /** Abort a running future. */
+    abortFuture(jobId: string): Promise<void>;
+    /**
+     * Poll until the future carries a result and return that result. Throws on
+     * an aborted or failed future and on an exhausted budget, so a caller never
+     * mistakes an unfinished future for a successful one.
+     */
+    waitForFuture(jobId: string, options?: ProjectGitFutureWaitOptions): Promise<unknown>;
+    private gitPath;
+    private actionPath;
+    private libraryPath;
+    private query;
+    private request;
+}