dataiku-sdk 0.12.6 → 1.0.0

package/dist/src/resources/connections.js

@@ -9,27 +9,89 @@ function normalizeConnectionNames(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/`);
+export async function resolveAdminManagedStorageConnection(client, capability, preferredName) {
+    try {
+        const raw = await client.get("/public/api/admin/connections/");
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const candidates = [];
+        for (const [name, value,] of Object.entries(raw)) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            const details = value;
+            if (details["allowWrite"] === true && details[capability] === true) {
+                candidates.push(name);
+            }
+        }
+        candidates.sort();
+        return preferredName && candidates.includes(preferredName) ? preferredName : candidates[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+async function inferRichConnections(client, projectEnc) {
+    const datasetsRaw = await client.get(`/public/api/projects/${projectEnc}/datasets/`);
+    const datasets = Array.isArray(datasetsRaw) ? datasetsRaw : [];
     const map = new Map();
-    for (const ds of datasets) {
-        const d = ds;
-        const params = d["params"];
-        const connection = params?.["connection"];
+    const recordConnection = (connection, type, managed, schema) => {
         if (typeof connection !== "string" || connection.length === 0)
-            continue;
-        if (!map.has(connection)) {
-            map.set(connection, { types: new Set(), managed: false, dbSchemas: new Set(), });
+            return;
+        let entry = map.get(connection);
+        if (!entry) {
+            entry = { types: new Set(), managed: false, dbSchemas: new Set(), };
+            map.set(connection, entry);
         }
-        const entry = map.get(connection);
-        const dsType = d["type"];
-        if (typeof dsType === "string" && dsType.length > 0)
-            entry.types.add(dsType);
-        if (d["managed"] === true)
+        if (typeof type === "string" && type.length > 0)
+            entry.types.add(type);
+        if (managed)
             entry.managed = true;
-        const schema = params?.["schema"];
         if (typeof schema === "string" && schema.length > 0)
             entry.dbSchemas.add(schema);
+    };
+    for (const dataset of datasets) {
+        if (!dataset || typeof dataset !== "object" || Array.isArray(dataset))
+            continue;
+        const details = dataset;
+        const params = details["params"];
+        if (!params || typeof params !== "object" || Array.isArray(params))
+            continue;
+        const datasetParams = params;
+        recordConnection(datasetParams["connection"], details["type"], details["managed"] === true, datasetParams["schema"]);
+        recordConnection(datasetParams["uploadConnection"], details["type"], false);
+    }
+    try {
+        const foldersRaw = await client.get(`/public/api/projects/${projectEnc}/managedfolders/`);
+        const folders = Array.isArray(foldersRaw) ? foldersRaw : [];
+        const folderDetails = await Promise.all(folders.map(async (folder) => {
+            if (!folder || typeof folder !== "object" || Array.isArray(folder))
+                return folder;
+            const summary = folder;
+            const params = summary["params"];
+            if (params && typeof params === "object" && !Array.isArray(params))
+                return summary;
+            const id = summary["id"];
+            if (typeof id !== "string" || id.length === 0)
+                return summary;
+            try {
+                return await client.get(`/public/api/projects/${projectEnc}/managedfolders/${encodeURIComponent(id)}`);
+            }
+            catch {
+                return summary;
+            }
+        }));
+        for (const folder of folderDetails) {
+            if (!folder || typeof folder !== "object" || Array.isArray(folder))
+                continue;
+            const details = folder;
+            const params = details["params"];
+            if (!params || typeof params !== "object" || Array.isArray(params))
+                continue;
+            recordConnection(params["connection"], details["type"], true);
+        }
+    }
+    catch {
+        // Dataset-derived inference remains useful when managed folders are inaccessible.
     }
     return [...map.entries(),]
         .sort(([a,], [b,]) => a.localeCompare(b))
@@ -48,9 +110,8 @@ export class ConnectionsResource extends BaseResource {
      * Returns sorted list of all connection names visible to the current user.
      */
     async list(opts) {
-        const type = opts?.type?.trim();
-        const query = type ? `?type=${encodeURIComponent(type)}` : "";
-        const raw = await this.client.get(`/public/api/connections/get-names/${query}`);
+        const type = opts?.type?.trim() || "all";
+        const raw = await this.client.get(`/public/api/connections/get-names/?type=${encodeURIComponent(type)}`);
         return normalizeConnectionNames(raw);
     }
     /**
@@ -58,14 +119,14 @@ export class ConnectionsResource extends BaseResource {
      *
      * - fast (default): fetches the connection name list and maps to ConnectionSummary.
      *   Falls back to rich mode on any failure or empty result set.
-     * - rich: inspects project datasets to derive connection metadata
+     * - rich: inspects project datasets and managed folders 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);
+            return inferRichConnections(this.client, projectEnc);
         }
         // fast — attempt name list, fall back to rich on any error or empty result
         try {
@@ -77,7 +138,7 @@ export class ConnectionsResource extends BaseResource {
         catch {
             // Fall through to rich inference.
         }
-        return inferRichConnectionsFromDatasets(this.client, projectEnc);
+        return inferRichConnections(this.client, projectEnc);
     }
     async schemas(opts) {
         const pk = this.resolveProjectKey(opts.projectKey);

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

@@ -2,18 +2,32 @@ import type { DashboardDetails, DashboardSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export interface DashboardCreateOptions {
     name: string;
+    listed?: boolean;
     settings?: Record<string, unknown>;
     projectKey?: string;
 }
 export interface DashboardUpdateOptions {
     name?: string;
+    listed?: boolean;
     data?: Record<string, unknown>;
     projectKey?: string;
 }
+export type DashboardExportOrientation = "PORTRAIT" | "LANDSCAPE";
+export type DashboardExportFileType = "PDF";
+export interface DashboardExportOptions {
+    paperSize?: string;
+    orientation?: DashboardExportOrientation;
+    fileType?: DashboardExportFileType;
+    slideIndex?: number;
+    projectKey?: string;
+}
 export declare class DashboardsResource extends BaseResource {
     list(projectKey?: string): Promise<DashboardSummary[]>;
     get(dashboardId: string, projectKey?: string): Promise<DashboardDetails>;
+    private referencedInsightIds;
+    private validateReferences;
     create(opts: DashboardCreateOptions): Promise<DashboardDetails>;
     update(dashboardId: string, opts: DashboardUpdateOptions): Promise<DashboardDetails>;
+    export(dashboardId: string, opts?: DashboardExportOptions): Promise<Response>;
     delete(dashboardId: string, projectKey?: string): Promise<void>;
 }

package/dist/src/resources/dashboards.js

@@ -1,6 +1,17 @@
-import { DashboardDetailsSchema, DashboardSummaryArraySchema, } from "../schemas.js";
+import { ClientValidationError, DataikuError, } from "../errors.js";
+import { DashboardDetailsSchema, DashboardSummaryArraySchema, InsightDetailsSchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
 import { BaseResource, } from "./base.js";
+const REFERENCE_VALIDATION_CONCURRENCY = 8;
+async function validateInBatches(items, validate) {
+    for (let offset = 0; offset < items.length; offset += REFERENCE_VALIDATION_CONCURRENCY) {
+        const batch = items.slice(offset, offset + REFERENCE_VALIDATION_CONCURRENCY);
+        const results = await Promise.allSettled(batch.map(validate));
+        const failure = results.find((result) => result.status === "rejected");
+        if (failure)
+            throw failure.reason;
+    }
+}
 export class DashboardsResource extends BaseResource {
     async list(projectKey) {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/dashboards/`);
@@ -10,19 +21,160 @@ export class DashboardsResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/dashboards/${encodeURIComponent(dashboardId)}/`);
         return this.client.safeParse(DashboardDetailsSchema, raw, "dashboards.get");
     }
+    referencedInsightIds(settings) {
+        const pages = settings.pages;
+        if (pages === undefined)
+            return [];
+        if (!Array.isArray(pages)) {
+            throw new ClientValidationError("Dashboard pages must be an array.");
+        }
+        const insightIds = new Set();
+        for (const [pageIndex, page,] of pages.entries()) {
+            if (!page || typeof page !== "object" || Array.isArray(page)) {
+                throw new ClientValidationError(`Dashboard page ${pageIndex} must be an object.`);
+            }
+            const grid = page.grid;
+            if (grid === undefined)
+                continue;
+            if (!grid || typeof grid !== "object" || Array.isArray(grid)) {
+                throw new ClientValidationError(`Dashboard page ${pageIndex} grid must be an object.`);
+            }
+            const tiles = grid.tiles;
+            if (tiles === undefined)
+                continue;
+            if (!Array.isArray(tiles)) {
+                throw new ClientValidationError(`Dashboard page ${pageIndex} grid tiles must be an array.`);
+            }
+            for (const [tileIndex, tile,] of tiles.entries()) {
+                if (!tile || typeof tile !== "object" || Array.isArray(tile)) {
+                    throw new ClientValidationError(`Dashboard page ${pageIndex} tile ${tileIndex} must be an object.`);
+                }
+                const record = tile;
+                const insightId = record.insightId ?? undefined;
+                const targetInsightId = record.targetInsightId ?? undefined;
+                const isInsight = record.tileType === "INSIGHT"
+                    || insightId !== undefined
+                    || targetInsightId !== undefined;
+                if (!isInsight)
+                    continue;
+                if (insightId !== undefined
+                    && (typeof insightId !== "string" || insightId.trim().length === 0)) {
+                    throw new ClientValidationError(`Dashboard page ${pageIndex} tile ${tileIndex} insightId must be a non-empty string.`);
+                }
+                if (targetInsightId !== undefined
+                    && (typeof targetInsightId !== "string" || targetInsightId.trim().length === 0)) {
+                    throw new ClientValidationError(`Dashboard page ${pageIndex} tile ${tileIndex} targetInsightId must be a non-empty string.`);
+                }
+                const normalizedInsightId = typeof insightId === "string" ? insightId.trim() : undefined;
+                const normalizedTargetId = typeof targetInsightId === "string"
+                    ? targetInsightId.trim()
+                    : undefined;
+                if (normalizedInsightId !== undefined
+                    && normalizedTargetId !== undefined
+                    && normalizedInsightId !== normalizedTargetId) {
+                    throw new ClientValidationError(`Dashboard page ${pageIndex} tile ${tileIndex} has mismatched insightId and targetInsightId.`);
+                }
+                const reference = normalizedInsightId ?? normalizedTargetId;
+                if (!reference) {
+                    throw new ClientValidationError(`Dashboard page ${pageIndex} tile ${tileIndex} requires insightId or targetInsightId.`);
+                }
+                insightIds.add(reference);
+            }
+        }
+        return [...insightIds,];
+    }
+    async validateReferences(settings, projectKey) {
+        const insightIds = this.referencedInsightIds(settings);
+        const datasetNames = new Set();
+        await validateInBatches(insightIds, async (insightId) => {
+            let raw;
+            try {
+                raw = await this.client.get(`/public/api/projects/${encodeURIComponent(projectKey)}/insights/${encodeURIComponent(insightId)}/`);
+            }
+            catch (error) {
+                if (error instanceof DataikuError && error.status === 404) {
+                    throw new ClientValidationError(`Dashboard references missing insight ${insightId}.`, "validation_failed", "Create or restore the insight, then update the tile reference before saving the dashboard.", { insightId, });
+                }
+                throw error;
+            }
+            const insight = this.client.safeParse(InsightDetailsSchema, raw, `dashboards.validateReferences.insight.${insightId}`);
+            const params = raw && typeof raw === "object" && !Array.isArray(raw)
+                ? raw.params
+                : undefined;
+            const datasetSmartName = params && typeof params === "object" && !Array.isArray(params)
+                ? params.datasetSmartName
+                : undefined;
+            if (insight.type === "dataset_table" && (typeof datasetSmartName !== "string" || datasetSmartName.trim().length === 0)) {
+                throw new ClientValidationError(`Dashboard insight ${insightId} does not name a backing dataset.`, "validation_failed", "Retarget the dataset-table insight before saving the dashboard.", { insightId, });
+            }
+            if (typeof datasetSmartName === "string" && datasetSmartName.trim().length > 0) {
+                datasetNames.add(datasetSmartName.trim());
+            }
+        });
+        await validateInBatches([...datasetNames,], async (datasetSmartName) => {
+            const separatorIndex = datasetSmartName.indexOf(".");
+            if (separatorIndex === 0 || separatorIndex === datasetSmartName.length - 1) {
+                throw new ClientValidationError(`Dashboard insight has invalid dataset smart name ${datasetSmartName}.`, "validation_failed", "Use DATASET for the current project or PROJECT.DATASET for a cross-project dataset.", { datasetSmartName, });
+            }
+            const datasetProjectKey = separatorIndex > 0
+                ? datasetSmartName.slice(0, separatorIndex)
+                : projectKey;
+            const datasetName = separatorIndex > 0
+                ? datasetSmartName.slice(separatorIndex + 1)
+                : datasetSmartName;
+            try {
+                await this.client.get(`/public/api/projects/${encodeURIComponent(datasetProjectKey)}/datasets/${encodeURIComponent(datasetName)}/`);
+            }
+            catch (error) {
+                if (error instanceof DataikuError && error.status === 403) {
+                    throw new ClientValidationError(`Dashboard cannot validate inaccessible dataset ${datasetSmartName}.`, "validation_failed", "Grant the API key read access to the dataset project before saving the dashboard.", { datasetSmartName, datasetProjectKey, datasetName, });
+                }
+                if (error instanceof DataikuError && error.status === 404) {
+                    throw new ClientValidationError(`Dashboard insight references missing dataset ${datasetSmartName}.`, "validation_failed", "Create or restore the dataset, or retarget the insight before saving the dashboard.", { datasetSmartName, datasetProjectKey, datasetName, });
+                }
+                throw error;
+            }
+        });
+    }
     async create(opts) {
         const pk = this.resolveProjectKey(opts.projectKey);
         const body = { ...(opts.settings ?? { pages: [], }), name: opts.name, };
+        if (opts.listed !== undefined)
+            body.listed = opts.listed;
+        await this.validateReferences(body, pk);
         const created = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/dashboards/`, body);
         return this.get(created.id, pk);
     }
     async update(dashboardId, opts) {
-        const current = await this.get(dashboardId, opts.projectKey);
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const current = await this.get(dashboardId, pk);
         const next = deepMerge(current, opts.data ?? {});
         if (opts.name !== undefined)
             next.name = opts.name;
-        const raw = await this.client.put(`/public/api/projects/${this.enc(opts.projectKey)}/dashboards/${encodeURIComponent(dashboardId)}/`, next);
-        return this.client.safeParse(DashboardDetailsSchema, raw, "dashboards.update");
+        if (opts.listed !== undefined)
+            next.listed = opts.listed;
+        await this.validateReferences(next, pk);
+        await this.client.put(`/public/api/projects/${encodeURIComponent(pk)}/dashboards/${encodeURIComponent(dashboardId)}/`, next);
+        return this.get(dashboardId, pk);
+    }
+    async export(dashboardId, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const paperSize = (opts.paperSize ?? "A4").trim();
+        if (!paperSize)
+            throw new ClientValidationError("Dashboard export paperSize must not be empty.");
+        const orientation = (opts.orientation ?? "LANDSCAPE").trim().toUpperCase();
+        if (orientation !== "PORTRAIT" && orientation !== "LANDSCAPE") {
+            throw new ClientValidationError("Dashboard export orientation must be PORTRAIT or LANDSCAPE.");
+        }
+        const fileType = (opts.fileType ?? "PDF").trim().toUpperCase();
+        if (fileType !== "PDF") {
+            throw new ClientValidationError("Dashboard export fileType must be PDF.");
+        }
+        const slideIndex = opts.slideIndex ?? 0;
+        if (!Number.isInteger(slideIndex) || slideIndex < 0) {
+            throw new ClientValidationError("Dashboard export slideIndex must be a non-negative integer.");
+        }
+        return this.client.postStream(`/public/api/projects/${encodeURIComponent(pk)}/dashboards/${encodeURIComponent(dashboardId)}/action/export`, { paperSize, orientation, fileType, slideIndex, });
     }
     async delete(dashboardId, projectKey) {
         await this.client.del(`/public/api/projects/${this.enc(projectKey)}/dashboards/${encodeURIComponent(dashboardId)}/`);

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
 // ---------------------------------------------------------------------------
@@ -253,15 +254,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,
@@ -481,6 +492,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;
             }

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;
+}