dataiku-sdk 3.6.1 → 3.8.0

package/dist/src/resources/flow.js

@@ -0,0 +1,65 @@
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, } from "./base.js";
+import { startDocumentation, } from "./documentation.js";
+import { dssTask, } from "./futures.js";
+/**
+ * Flow-wide tools: schema propagation from a dataset through every downstream
+ * recipe, and flow documentation export. Zones and the flow graph live on
+ * `flowZones`; per-recipe schema updates on `recipes.updateSchema`.
+ */
+export class FlowResource extends BaseResource {
+    flowPath(projectKey) {
+        return `/public/api/projects/${this.enc(projectKey)}/flow`;
+    }
+    /**
+     * Start propagating `datasetName`'s schema through the flow
+     * (POST /flow/tools/propagate-schema/, dataikuapi
+     * `new_schema_propagation(...).start()`). Returns the DSS future.
+     */
+    async propagateSchema(datasetName, opts = {}) {
+        const name = datasetName.trim();
+        if (name.length === 0) {
+            throw new ClientValidationError("propagateSchema requires a dataset name.", "validation_failed");
+        }
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const raw = await this.client.post(`${this.flowPath(pk)}/tools/propagate-schema/`, schemaPropagationBody(pk, name, opts));
+        return dssTask(raw, "Schema propagation");
+    }
+    async propagateSchemaAndWait(datasetName, opts = {}) {
+        return this.client.futures.waitTask(await this.propagateSchema(datasetName, opts), opts);
+    }
+    /**
+     * Start generating the flow documentation (docx) from the DSS default
+     * template, an uploaded docx template, or a docx in a managed folder.
+     * The finished future's result carries the `exportId` to download.
+     */
+    async generateDocumentation(template = { kind: "default", }, projectKey) {
+        const base = `${this.flowPath(projectKey)}/documentation`;
+        return startDocumentation(this.client, {
+            default: `${base}/generate`,
+            file: `${base}/generate-with-template`,
+            folder: `${base}/generate-with-template-in-folder`,
+        }, template, "Flow documentation generation");
+    }
+    /** GET a generated flow documentation (docx) as a binary stream. */
+    async downloadDocumentation(exportId, projectKey) {
+        return this.client.stream(`${this.flowPath(projectKey)}/documentation/generated/${encodeURIComponent(exportId)}`);
+    }
+}
+/** Request body of POST /flow/tools/propagate-schema/ (pure; shared with `--plan`). */
+export function schemaPropagationBody(projectKey, datasetName, opts) {
+    return {
+        options: {
+            recipeUpdateOptions: {
+                byType: opts.recipeUpdateOptions?.byType ?? {},
+                byName: opts.recipeUpdateOptions?.byName ?? {},
+            },
+            defaultPartitionValuesByDimension: opts.defaultPartitionValuesByDimension ?? {},
+            partitionsByComputable: opts.partitionsByComputable ?? {},
+            excludedRecipes: opts.excludedRecipes ?? [],
+            markAsOkRecipes: opts.markAsOkRecipes ?? [],
+            autoRebuild: opts.autoRebuild ?? true,
+        },
+        sources: [{ projectKey, id: datasetName, },],
+    };
+}

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

@@ -4,7 +4,30 @@ export interface FutureWaitOptions {
     pollIntervalMs?: number;
     timeoutMs?: number;
 }
+/**
+ * A DSS long task as started (dataikuapi `DSSFuture.from_resp`): `jobId`
+ * addresses a running task in `futures.wait`; a task DSS finished inline comes
+ * back without one, as its final state (`hasResult`, `result`).
+ */
+export interface DssTask {
+    jobId?: string;
+    hasResult?: boolean;
+    result?: unknown;
+    [key: string]: unknown;
+}
+/** Validate a task-start response: an object whose `jobId`, when present, is a string. */
+export declare function dssTask(raw: unknown, operation: string): DssTask;
 export declare class FuturesResource extends BaseResource {
+    /**
+     * Long tasks in progress (GET /futures/): the caller's own by default,
+     * every user's with `allUsers`, running scenarios too with `withScenarios`.
+     */
+    list(opts?: {
+        allUsers?: boolean;
+        withScenarios?: boolean;
+    }): Promise<FutureState[]>;
+    /** Wait for a started task; a task DSS already finished inline is returned as is. */
+    waitTask(task: DssTask, opts?: FutureWaitOptions): Promise<FutureWaitResult | DssTask>;
     get(futureId: string, opts?: {
         timeoutMs?: number;
         noRetry?: boolean;

package/dist/src/resources/futures.js

@@ -1,6 +1,18 @@
+import { unexpectedResponseError, } from "../errors.js";
 import { FutureStateSchema, FutureWaitResultSchema, } from "../schemas.js";
 import { computeNextPollDelayMs, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, isRequestDeadlineError, } from "../utils/polling.js";
 import { BaseResource, } from "./base.js";
+/** Validate a task-start response: an object whose `jobId`, when present, is a string. */
+export function dssTask(raw, operation) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw unexpectedResponseError(`${operation} returned no task state.`);
+    }
+    const state = { ...raw, };
+    if (state.jobId !== undefined && typeof state.jobId !== "string") {
+        throw unexpectedResponseError(`${operation} returned a non-string jobId.`);
+    }
+    return state;
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -22,6 +34,26 @@ function waitState(state) {
     return "RUNNING";
 }
 export class FuturesResource extends BaseResource {
+    /**
+     * Long tasks in progress (GET /futures/): the caller's own by default,
+     * every user's with `allUsers`, running scenarios too with `withScenarios`.
+     */
+    async list(opts = {}) {
+        const query = new URLSearchParams({
+            allUsers: String(opts.allUsers === true),
+            withScenarios: String(opts.withScenarios === true),
+        });
+        return this.client.get(`/public/api/futures/?${query}`);
+    }
+    /** Wait for a started task; a task DSS already finished inline is returned as is. */
+    async waitTask(task, opts = {}) {
+        if (task.jobId === undefined)
+            return task;
+        return this.wait(task.jobId, {
+            pollIntervalMs: opts.pollIntervalMs,
+            timeoutMs: opts.timeoutMs,
+        });
+    }
     async get(futureId, opts = {}) {
         return this.state(futureId, {
             peek: false,

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

@@ -23,12 +23,30 @@ export interface JobLogSummary {
 }
 /** Why a requested job log could not be retrieved. */
 export type JobLogUnavailableReason = "not_found" | "error";
+/**
+ * A requested build target that no flow object can ever produce: a managed
+ * dataset with no recipe writing it.
+ */
+export interface JobUnbuildableTarget {
+    type: "DATASET";
+    id: string;
+    projectKey: string;
+    reason: "no_producing_recipe";
+}
+/** Why a job that ended DONE is reported as failed because it built nothing. */
+export interface JobNothingToBuildFailure {
+    code: "nothing_to_build";
+    message: string;
+    targets: JobUnbuildableTarget[];
+}
 /** Result of a completed job wait, including log-unavailable metadata. */
 export type JobWaitOutcome = JobWaitResult & {
     logSummary?: JobLogSummary;
     logUnavailable?: JobLogUnavailableReason;
     /** True when the job itself no longer exists on the server. */
     removed?: boolean;
+    /** Set (with `success: false`) when a DONE job ran no activity and a target has no producer. */
+    failure?: JobNothingToBuildFailure;
 };
 export interface JobBuildTarget {
     id: string;
@@ -120,6 +138,12 @@ export declare class JobsResource extends BaseResource {
      * confirmed gone. Explicit `includeLogs`/`summary` requests stay honest:
      * `log`/`logSummary` are only present when logs were actually retrieved.
      *
+     * A DONE job that ran no activity (`progress.total === 0`) is also what DSS
+     * reports for an already-up-to-date build, so it stays successful unless an
+     * output is a managed dataset that no recipe writes: then nothing can ever
+     * build it, and the outcome is `success: false` with
+     * `failure.code === "nothing_to_build"`.
+     *
      * On timeout, returns `{ success: false, ... }` rather than throwing.
      */
     wait(jobId: string, opts?: {
@@ -133,6 +157,16 @@ export declare class JobsResource extends BaseResource {
         timeoutMs?: number;
         projectKey?: string;
     }): Promise<JobWaitOutcome>;
+    /**
+     * Dataset outputs of a job that ran no activity which nothing can produce.
+     * DSS ends such a job DONE exactly like an already-up-to-date build, so the
+     * job status cannot tell them apart; the flow graph can: a target is
+     * unbuildable when it is a managed dataset (DSS owns its storage, so a
+     * recipe is the only way to fill it) that no recipe writes. Unmanaged
+     * datasets (uploads, external tables) are sources and legitimately build
+     * nothing. Lookups that fail leave the DONE outcome untouched.
+     */
+    private unbuildableTargets;
     /**
      * Probe whether a job still exists. Returns `true` when the server reports
      * it as not found, `false` when it is still visible, and `undefined` when

package/dist/src/resources/jobs.js

@@ -1,6 +1,7 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { JobSummaryArraySchema, } from "../schemas.js";
 import { computeNextPollDelayMs, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, isRequestDeadlineError, } from "../utils/polling.js";
+import { asRecord, } from "../utils/records.js";
 import { BaseResource, } from "./base.js";
 const DEFAULT_MAX_LOG_LINES = 500;
 /**
@@ -73,6 +74,36 @@ function jobLogLines(log) {
  */
 const LEGACY_STDOUT_RECORD = /^\s*stdout:/i;
 const LEGACY_STDERR_RECORD = /^\s*stderr:/i;
+/**
+ * A DSS backend log record starts with a timestamped header line
+ * (`[YYYY/MM/DD-HH:MM:SS.mmm]`); every following non-timestamped line is a
+ * continuation of that record (exception chain, JVM frames, ...).
+ */
+const DSS_RECORD_HEADER = /^\[\d{4}\/\d{2}\/\d{2}-\d{2}:\d{2}:\d{2}\.\d{3}\]/;
+const ERROR_KEYWORDS = /\b(error|failed|failure|exception|traceback)\b/i;
+/**
+ * Exception class names ending in the `Exception`/`Error` suffix (e.g.
+ * `java.lang.ClassCastException`, `ValueError`): no word boundary precedes the
+ * suffix inside a compound name, so the keyword regex alone misses them.
+ */
+const ERROR_CLASS_NAME = /\b\w*(?:Exception|Error)\b/;
+const PY_TRACEBACK_HEAD = /^\s*Traceback \(most recent call last\):$/;
+const PY_FILE_FRAME = /^\s*File "(?:[^"\\]|\\.)*", line \d+/;
+const JVM_STACK_FRAME = /^\s+at\s/;
+const JVM_MORE_FRAMES = /^\s*\.\.\. \d+ more\b/;
+/**
+ * Message payload of a DSS record line: timestamp header and the
+ * `[thread] [LEVEL] [logger] -` prefix stripped, so continuation logic can be
+ * shared between timestamped records and raw log lines.
+ */
+function dssRecordMessage(line) {
+    return line
+        .replace(/^\[\d{4}\/\d{2}\/\d{2}-\d{2}:\d{2}:\d{2}\.\d{3}\]\s?/, "")
+        .replace(/^\[[^\]]*\] \[[^\]]*\] \[[^\]]*\]\s+-\s?/, "");
+}
+function isErrorContent(line) {
+    return ERROR_KEYWORDS.test(line) || ERROR_CLASS_NAME.test(line) || PY_FILE_FRAME.test(line);
+}
 function lineMatchesLogFilter(line, filter) {
     const normalized = line.toLowerCase();
     switch (filter) {
@@ -82,17 +113,87 @@ function lineMatchesLogFilter(line, filter) {
         case "stderr":
             return normalized.includes("[null-err-") || LEGACY_STDERR_RECORD.test(line);
         case "errors":
-            return /\b(error|failed|failure|exception|traceback)\b/i.test(line);
+            return isErrorContent(line);
         case "user":
             return !/^\d{4}[-/]\d{2}[-/]\d{2}/.test(line)
                 && !normalized.includes("backend-log")
                 && !normalized.includes("debug");
     }
 }
+/**
+ * Errors filter over DSS records. A record's exception spans lines: the
+ * timestamped header carries the level/message, untimestamped continuations
+ * carry the exception chain. A record whose header matches the error keywords
+ * keeps its cause-bearing continuation lines (exception headers like
+ * `pkg.FooException: msg`, `Caused by:` chains, Python `Traceback` essentials)
+ * and drops bare JVM stack frames. A Python traceback body is tracked as state,
+ * so `File "..."` frames and the user-code source line survive even though they
+ * carry no error keyword — including when DSS re-logs each child-stderr line as
+ * its own timestamped record.
+ */
+function filterJobLogToErrors(lines) {
+    const kept = [];
+    let recordMatches = false;
+    let pyTraceback = false;
+    for (const line of lines) {
+        const isHeader = DSS_RECORD_HEADER.test(line);
+        const message = dssRecordMessage(line);
+        if (pyTraceback) {
+            if (JVM_STACK_FRAME.test(line) || JVM_MORE_FRAMES.test(line)) {
+                if (isHeader)
+                    recordMatches = false;
+                continue;
+            }
+            if (/^\s+\S/.test(message)) {
+                kept.push(line); // `File "..."` frame or user-code source line
+                if (isHeader)
+                    recordMatches = false;
+                continue;
+            }
+            if (ERROR_CLASS_NAME.test(message)) {
+                kept.push(line); // terminating exception line
+                pyTraceback = false;
+                if (isHeader)
+                    recordMatches = false;
+                continue;
+            }
+            pyTraceback = false;
+        }
+        if (isHeader) {
+            recordMatches = isErrorContent(line) || PY_FILE_FRAME.test(message);
+            if (recordMatches && (PY_TRACEBACK_HEAD.test(message) || PY_FILE_FRAME.test(message))) {
+                pyTraceback = true;
+            }
+            if (recordMatches)
+                kept.push(line);
+            continue;
+        }
+        if (PY_TRACEBACK_HEAD.test(message)) {
+            kept.push(line);
+            pyTraceback = true;
+            continue;
+        }
+        if (recordMatches
+            && !JVM_STACK_FRAME.test(line)
+            && !JVM_MORE_FRAMES.test(line)
+            && isErrorContent(line))
+            kept.push(line);
+    }
+    return kept.join("\n");
+}
+/**
+ * Filter a job log. DSS logs (any timestamped record) use the record-aware
+ * errors pass; untimestamped (non-DSS) logs keep the per-line behaviour, since
+ * no record structure can be inferred.
+ */
 function filterJobLog(log, filter) {
     if (!filter)
         return log;
-    return jobLogLines(log).filter((line) => lineMatchesLogFilter(line, filter)).join("\n");
+    const lines = jobLogLines(log);
+    if (filter !== "errors" || !lines.some((line) => DSS_RECORD_HEADER.test(line))) {
+        return lines.filter((line) => lineMatchesLogFilter(line, filter)).join("\n");
+    }
+    return filterJobLogToErrors(lines);
 }
 function limitJobLog(log, maxLines) {
     if (!log)
@@ -163,6 +264,10 @@ function summarizeJobLog(state, log, maxLines, elapsedMs) {
         ...(progress ? { progress, } : {}),
     };
 }
+function nothingToBuildMessage(targets) {
+    const names = targets.map((target) => `${target.projectKey}.${target.id}`).join(", ");
+    return `The job ran no activity: ${names} ${targets.length === 1 ? "is a managed dataset" : "are managed datasets"} that no recipe produces, so nothing was built. Create a recipe that writes ${targets.length === 1 ? "it" : "them"} or build the recipe's output instead.`;
+}
 export class JobsResource extends BaseResource {
     /** List jobs in a project. */
     async list(projectKey) {
@@ -275,6 +380,12 @@ export class JobsResource extends BaseResource {
      * confirmed gone. Explicit `includeLogs`/`summary` requests stay honest:
      * `log`/`logSummary` are only present when logs were actually retrieved.
      *
+     * A DONE job that ran no activity (`progress.total === 0`) is also what DSS
+     * reports for an already-up-to-date build, so it stays successful unless an
+     * output is a managed dataset that no recipe writes: then nothing can ever
+     * build it, and the outcome is `success: false` with
+     * `failure.code === "nothing_to_build"`.
+     *
      * On timeout, returns `{ success: false, ... }` rather than throwing.
      */
     async wait(jobId, opts) {
@@ -392,8 +503,18 @@ export class JobsResource extends BaseResource {
                         }
                     }
                 }
+                const unbuildable = success && gs.total === 0
+                    ? await this.unbuildableTargets(def.outputs, def.projectKey ?? opts?.projectKey)
+                    : [];
+                const failure = unbuildable.length > 0
+                    ? {
+                        code: "nothing_to_build",
+                        message: nothingToBuildMessage(unbuildable),
+                        targets: unbuildable,
+                    }
+                    : undefined;
                 return {
-                    success,
+                    success: success && failure === undefined,
                     jobId: def.id ?? jobId,
                     state,
                     type: def.type ?? "unknown",
@@ -405,6 +526,7 @@ export class JobsResource extends BaseResource {
                         running: gs.running ?? 0,
                         total: gs.total ?? null,
                     },
+                    ...(failure !== undefined ? { failure, } : {}),
                     ...(log !== undefined ? { log, } : {}),
                     ...(logSummary !== undefined ? { logSummary, } : {}),
                     ...(logUnavailable !== undefined ? { logUnavailable, } : {}),
@@ -423,6 +545,51 @@ export class JobsResource extends BaseResource {
             await sleep(Math.min(nextDelayMs, timeout - elapsedMs));
         }
     }
+    /**
+     * Dataset outputs of a job that ran no activity which nothing can produce.
+     * DSS ends such a job DONE exactly like an already-up-to-date build, so the
+     * job status cannot tell them apart; the flow graph can: a target is
+     * unbuildable when it is a managed dataset (DSS owns its storage, so a
+     * recipe is the only way to fill it) that no recipe writes. Unmanaged
+     * datasets (uploads, external tables) are sources and legitimately build
+     * nothing. Lookups that fail leave the DONE outcome untouched.
+     */
+    async unbuildableTargets(outputs, fallbackProjectKey) {
+        if (!Array.isArray(outputs))
+            return [];
+        const writtenByProject = new Map();
+        const unbuildable = [];
+        for (const output of outputs) {
+            const record = asRecord(output);
+            if (record?.type !== "DATASET" || typeof record.targetDataset !== "string")
+                continue;
+            const id = record.targetDataset;
+            const projectKey = typeof record.targetDatasetProjectKey === "string"
+                ? record.targetDatasetProjectKey
+                : fallbackProjectKey;
+            if (projectKey === undefined)
+                continue;
+            try {
+                const details = await this.client.datasets.get(id, projectKey);
+                if (details.managed !== true)
+                    continue;
+                let written = writtenByProject.get(projectKey);
+                if (written === undefined) {
+                    const { graph, } = await this.client.projects.flowTopology(projectKey);
+                    written = new Set(graph.edges.filter((edge) => edge.relation === "writes").map((edge) => edge.to));
+                    writtenByProject.set(projectKey, written);
+                }
+                if (!written.has(id)) {
+                    unbuildable.push({ type: "DATASET", id, projectKey, reason: "no_producing_recipe", });
+                }
+            }
+            catch (error) {
+                if (!(error instanceof DataikuError || error instanceof ClientValidationError))
+                    throw error;
+            }
+        }
+        return unbuildable;
+    }
     /**
      * Probe whether a job still exists. Returns `true` when the server reports
      * it as not found, `false` when it is still visible, and `undefined` when

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

@@ -37,6 +37,16 @@ export declare class MetricsResource extends BaseResource {
     getDatasetMetrics(datasetName: string, projectKey?: string): Promise<MetricValues>;
     /** Compute the dataset metrics configured in DSS for the default partition. */
     computeDatasetMetrics(datasetName: string, projectKey?: string): Promise<MetricComputationReport>;
+    /**
+     * Run the dataset's checks (POST /actions/runChecks/{?partitions}). Without
+     * `checks` DSS runs the checks configured on the dataset; with `checks` it
+     * runs those definitions instead (body `{"checks": [...]}`).
+     */
+    runDatasetChecks(datasetName: string, opts?: {
+        projectKey?: string;
+        partitions?: string;
+        checks?: unknown[];
+    }): Promise<MetricComputationReport>;
     /** Get the last metric values for a managed folder. */
     getFolderMetrics(folderId: string, projectKey?: string): Promise<MetricValues>;
     /** Get the metric history for a dataset's global partition. */

package/dist/src/resources/metrics.js

@@ -16,6 +16,16 @@ export class MetricsResource extends BaseResource {
         const pk = this.enc(projectKey);
         return this.client.post(`${datasetPath(pk, datasetName)}/actions/computeMetrics?partition=`);
     }
+    /**
+     * Run the dataset's checks (POST /actions/runChecks/{?partitions}). Without
+     * `checks` DSS runs the checks configured on the dataset; with `checks` it
+     * runs those definitions instead (body `{"checks": [...]}`).
+     */
+    async runDatasetChecks(datasetName, opts = {}) {
+        const pk = this.enc(opts.projectKey);
+        const query = opts.partitions ? `?partitions=${encodeURIComponent(opts.partitions)}` : "";
+        return this.client.post(`${datasetPath(pk, datasetName)}/actions/runChecks/${query}`, opts.checks ? { checks: opts.checks, } : undefined);
+    }
     /** Get the last metric values for a managed folder. */
     async getFolderMetrics(folderId, projectKey) {
         const pk = this.enc(projectKey);

package/dist/src/resources/ml-tasks.d.ts

@@ -1,14 +1,41 @@
 import { BaseResource } from "./base.js";
+import { TrainedModel } from "./trained-model.js";
 export type MlTaskType = "PREDICTION" | "CLUSTERING";
-export interface MlTaskCreateOptions {
-    analysisId: string;
+/** ML task definition; time series forecasting is PREDICTION with predictionType TIMESERIES_FORECAST. */
+export interface MlTaskCreateFields {
     taskType: MlTaskType;
     targetVariable?: string;
     predictionType?: string;
+    /** Forecasting tasks: the parsed-date time column. */
+    timeVariable?: string;
+    /** Forecasting tasks: columns identifying each series of a multi-series dataset. */
+    timeseriesIdentifiers?: string[];
     backendType?: string;
     guessPolicy?: string;
     projectKey?: string;
 }
+export interface MlTaskCreateOptions extends MlTaskCreateFields {
+    analysisId: string;
+}
+export interface MlTaskCreateForDatasetOptions extends MlTaskCreateFields {
+    inputDataset: string;
+}
+export interface MlTaskListItem extends Record<string, unknown> {
+    analysisId?: string;
+    mlTaskId?: string;
+    analysisName?: string;
+    mlTaskName?: string;
+    taskType?: string;
+    inputDataset?: string;
+}
+export interface MlTaskReguessOptions {
+    predictionType?: string;
+    targetVariable?: string;
+    timeVariable?: string;
+    timeseriesIdentifiers?: string[];
+    /** Re-guess every setting after the core change, not just the impacted ones. */
+    fullReguess?: boolean;
+}
 export interface MlTaskCreateResult extends Record<string, unknown> {
     analysisId?: string;
     mlTaskId?: string;
@@ -91,6 +118,14 @@ export interface MlTaskDeployResult extends Record<string, unknown> {
     savedModelId?: string;
     trainRecipeName?: string;
 }
+/** Query of POST .../guess; repeated `timeseriesIdentifiers` as dataikuapi sends a list (pure; shared with `--plan`). */
+export declare function mlTaskReguessQuery(opts: MlTaskReguessOptions): URLSearchParams;
+/**
+ * Task-creation body shared by `create` (existing analysis) and
+ * `createForDataset` (new analysis), with dataikuapi's defaults (pure; shared
+ * with `--plan`).
+ */
+export declare function mlTaskCreateBody(opts: MlTaskCreateFields): Record<string, unknown>;
 export declare class MlTasksResource extends BaseResource {
     /** Create a prediction or clustering task in an existing visual analysis. */
     create(opts: MlTaskCreateOptions): Promise<MlTaskCreateResult>;
@@ -122,5 +157,33 @@ export declare class MlTasksResource extends BaseResource {
     deployToFlow(opts: MlTaskDeployOptions): Promise<MlTaskDeployResult>;
     /** Delete an ML task and its trained models. */
     delete(analysisId: string, mlTaskId: string, projectKey?: string): Promise<void>;
+    /** Every ML task of the project, with its visual analysis (GET /models/lab/). */
+    list(projectKey?: string): Promise<MlTaskListItem[]>;
+    /**
+     * Create a new visual analysis on `inputDataset` with one ML task
+     * (POST /models/lab/). Returns `{analysisId, mlTaskId}`; DSS guesses the
+     * settings asynchronously (watch `status().guessing`).
+     */
+    createForDataset(opts: MlTaskCreateForDatasetOptions): Promise<MlTaskCreateResult>;
+    /**
+     * Re-guess the task settings: all of them, or (prediction tasks) after
+     * setting a new prediction type, target, time variable, or series
+     * identifiers — only the impacted settings unless `fullReguess`.
+     */
+    reguess(analysisId: string, mlTaskId: string, opts?: MlTaskReguessOptions, projectKey?: string): Promise<void>;
+    /**
+     * Time series forecasting tasks: change the forecasting parameters
+     * (`forecastHorizon`, `validationHorizons`, `timestepParams`,
+     * `updateAlgorithmSettings`) and re-guess the impacted algorithm settings.
+     */
+    reguessForecasting(analysisId: string, mlTaskId: string, params: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /**
+     * One trained lab model as a {@link TrainedModel}: diagnostics
+     * (subpopulation analyses, partial dependencies, timeseries residuals and
+     * per-series results), documentation, scoring exports, user metadata.
+     */
+    model(analysisId: string, mlTaskId: string, modelId: string, projectKey?: string): TrainedModel;
+    /** GET a generated lab model documentation (docx) by the `exportId` of its finished future. */
+    downloadModelDocumentation(exportId: string, projectKey?: string): Promise<Response>;
     private taskPath;
 }