dataiku-sdk 0.11.0 → 0.12.0

package/dist/src/cli/flags.js

@@ -37,6 +37,7 @@ export const BOOLEAN_FLAGS = new Set([
     "keep",
     "full-log",
     "drop-data",
+    "normalize",
 ]);
 export const SHORT_FLAGS = {
     v: "verbose",
@@ -66,6 +67,7 @@ export const VALUE_FLAGS = new Set([
     "api-key",
     "build-mode",
     "backup-dir",
+    "backend-type",
     "backup",
     "ca-cert",
     "catalog",
@@ -86,12 +88,19 @@ export const VALUE_FLAGS = new Set([
     "file",
     "env",
     "install-core-packages",
+    "fuzzy-on",
+    "fuzzy-distance",
+    "guess-policy",
+    "fuzzy-threshold",
     "folder",
     "input",
+    "input-dataset",
     "from",
     "knowledge-bank",
     "labeling-task",
     "lang",
+    "join-on",
+    "join-type",
     "package",
     "packages",
     "local",
@@ -110,6 +119,7 @@ export const VALUE_FLAGS = new Set([
     "log-filter",
     "log-id",
     "model-evaluation-store",
+    "model-name",
     "name",
     "object",
     "metastore-table",
@@ -122,6 +132,7 @@ export const VALUE_FLAGS = new Set([
     "parent",
     "path",
     "preview",
+    "prediction-type",
     "project-key",
     "recipe",
     "request-timeout",
@@ -138,6 +149,7 @@ export const VALUE_FLAGS = new Set([
     "replace-payload-text",
     "retain",
     "saved-model",
+    "session-name",
     "sql",
     "schema",
     "sql-file",
@@ -145,6 +157,9 @@ export const VALUE_FLAGS = new Set([
     "state",
     "streaming-endpoint",
     "target",
+    "task-type",
+    "test-dataset",
+    "train-dataset",
     "target-type",
     "timeout",
     "table",
@@ -158,7 +173,9 @@ export const VALUE_FLAGS = new Set([
 export const REPEATABLE_VALUE_FLAGS = new Set([
     "dataset",
     "folder",
+    "fuzzy-on",
     "input",
+    "join-on",
     "object",
     "package",
     "recipe",

package/dist/src/cli/helpers/cleanup.js

@@ -3,7 +3,8 @@ export function projectArg(projectKey) {
     return projectKey ? ["--project-key", projectKey,] : [];
 }
 export function cleanupLedgerEntry(resource, action, args, flags, result, projectKey) {
-    if (!(action.startsWith("create") || action === "clone" || action === "upload"))
+    if (!(action.startsWith("create") || action === "clone" || action === "duplicate"
+        || action === "upload"))
         return undefined;
     const record = resultRecord(result);
     if (record.skipped !== undefined)
@@ -122,6 +123,39 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 cleanup: { argv: ["insight", "delete", id, "--if-exists", ...withProject,], },
             };
         }
+        case "analysis.create": {
+            const id = stringField(record, ["created", "id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                cleanup: { argv: ["analysis", "delete", id, "--if-exists", ...withProject,], },
+            };
+        }
+        case "model-evaluation-store.create": {
+            const id = stringField(record, ["created", "id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                cleanup: {
+                    argv: ["model-evaluation-store", "delete", id, "--if-exists", ...withProject,],
+                },
+            };
+        }
+        case "ml-task.create": {
+            const analysisId = args[0] || stringField(record, ["analysisId",]);
+            const taskId = stringField(record, ["created", "mlTaskId", "id",]);
+            if (!analysisId || !taskId)
+                return undefined;
+            return {
+                ...base,
+                id: taskId,
+                cleanup: { argv: ["ml-task", "delete", analysisId, taskId, ...withProject,], },
+            };
+        }
         case "data-quality.create-rule": {
             const ruleId = stringField(record, ["id", "created",]);
             if (!ruleId)
@@ -145,6 +179,18 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 cleanup: { argv: ["code-env", "delete", lang, name, "--if-exists",], },
             };
         }
+        case "project.duplicate": {
+            const targetKey = args[1];
+            if (!targetKey)
+                return undefined;
+            return {
+                ts,
+                action,
+                resource,
+                name: targetKey,
+                cleanup: { argv: ["project", "delete", targetKey, "--drop-data",], },
+            };
+        }
         case "folder.upload":
             return {
                 ...base,

package/dist/src/cli/usage.js

@@ -20,6 +20,10 @@ export const RESOURCE_NAMES = [
     "dashboard",
     "insight",
     "data-quality",
+    "analysis",
+    "ml-task",
+    "saved-model",
+    "model-evaluation-store",
     "future",
     "flow-zone",
     "dataset",

package/dist/src/client.d.ts

@@ -1,4 +1,5 @@
 import { type Static, type TSchema } from "@sinclair/typebox";
+import { AnalysesResource } from "./resources/analyses.js";
 import { ApiDeployerResource } from "./resources/api-deployer.js";
 import { ApiServicesResource } from "./resources/api-services.js";
 import { ApplicationsResource } from "./resources/applications.js";
@@ -17,10 +18,13 @@ import { InsightsResource } from "./resources/insights.js";
 import { JobsResource } from "./resources/jobs.js";
 import { MeaningsResource } from "./resources/meanings.js";
 import { MetricsResource } from "./resources/metrics.js";
+import { MlTasksResource } from "./resources/ml-tasks.js";
+import { ModelEvaluationStoresResource } from "./resources/model-evaluation-stores.js";
 import { NotebooksResource } from "./resources/notebooks.js";
 import { ProjectLibraryResource } from "./resources/project-library.js";
 import { ProjectsResource } from "./resources/projects.js";
 import { RecipesResource } from "./resources/recipes.js";
+import { SavedModelsResource } from "./resources/saved-models.js";
 import { ScenariosResource } from "./resources/scenarios.js";
 import { SqlResource } from "./resources/sql.js";
 import { StatisticsResource } from "./resources/statistics.js";
@@ -107,6 +111,10 @@ export declare class DataikuClient {
     private workspacesResource?;
     private metricsResource?;
     private meaningsResource?;
+    private analysesResource?;
+    private mlTasksResource?;
+    private savedModelsResource?;
+    private modelEvaluationStoresResource?;
     get projects(): ProjectsResource;
     get datasets(): DatasetsResource;
     get dashboards(): DashboardsResource;
@@ -138,6 +146,10 @@ export declare class DataikuClient {
     get workspaces(): WorkspacesResource;
     get metrics(): MetricsResource;
     get meanings(): MeaningsResource;
+    get analyses(): AnalysesResource;
+    get mlTasks(): MlTasksResource;
+    get savedModels(): SavedModelsResource;
+    get modelEvaluationStores(): ModelEvaluationStoresResource;
     constructor(config?: DataikuClientConfig);
     getRequestTimeoutMs(): number;
     resolveProjectKey(paramValue?: string): string;

package/dist/src/client.js

@@ -3,6 +3,7 @@ import { getCACertificates, } from "node:tls";
 import { Value, } from "@sinclair/typebox/value";
 import { safeParseSchema, } from "./schemas.js";
 import { classifyDataikuError, DataikuError, } from "./errors.js";
+import { AnalysesResource, } from "./resources/analyses.js";
 import { ApiDeployerResource, } from "./resources/api-deployer.js";
 import { ApiServicesResource, } from "./resources/api-services.js";
 import { ApplicationsResource, } from "./resources/applications.js";
@@ -21,10 +22,13 @@ import { InsightsResource, } from "./resources/insights.js";
 import { JobsResource, } from "./resources/jobs.js";
 import { MeaningsResource, } from "./resources/meanings.js";
 import { MetricsResource, } from "./resources/metrics.js";
+import { MlTasksResource, } from "./resources/ml-tasks.js";
+import { ModelEvaluationStoresResource, } from "./resources/model-evaluation-stores.js";
 import { NotebooksResource, } from "./resources/notebooks.js";
 import { ProjectLibraryResource, } from "./resources/project-library.js";
 import { ProjectsResource, } from "./resources/projects.js";
 import { RecipesResource, } from "./resources/recipes.js";
+import { SavedModelsResource, } from "./resources/saved-models.js";
 import { ScenariosResource, } from "./resources/scenarios.js";
 import { SqlResource, } from "./resources/sql.js";
 import { StatisticsResource, } from "./resources/statistics.js";
@@ -176,6 +180,10 @@ export class DataikuClient {
     workspacesResource;
     metricsResource;
     meaningsResource;
+    analysesResource;
+    mlTasksResource;
+    savedModelsResource;
+    modelEvaluationStoresResource;
     get projects() {
         return (this.projectsResource ??= new ProjectsResource(this));
     }
@@ -269,6 +277,18 @@ export class DataikuClient {
     get meanings() {
         return (this.meaningsResource ??= new MeaningsResource(this));
     }
+    get analyses() {
+        return (this.analysesResource ??= new AnalysesResource(this));
+    }
+    get mlTasks() {
+        return (this.mlTasksResource ??= new MlTasksResource(this));
+    }
+    get savedModels() {
+        return (this.savedModelsResource ??= new SavedModelsResource(this));
+    }
+    get modelEvaluationStores() {
+        return (this.modelEvaluationStoresResource ??= new ModelEvaluationStoresResource(this));
+    }
     constructor(config) {
         const envUrl = process.env["DATAIKU_URL"]?.trim();
         const envApiKey = process.env["DATAIKU_API_KEY"]?.trim();

package/dist/src/index.d.ts

@@ -2,6 +2,7 @@ export { DataikuClient, type DataikuClientConfig, type DataikuClientTraceEvent,
 export { type CredentialValidationOptions, type CredentialValidationResult, validateCredentials, } from "./auth.js";
 export { type DssCredentials, getConfigDir, getCredentialsPath, loadCredentials, saveCredentials, } from "./config.js";
 export { ClientValidationError, DataikuError, type DataikuErrorCategory, type DataikuErrorTaxonomy, type DataikuRetryMetadata, } from "./errors.js";
+export * from "./resources/analyses.js";
 export { ApiDeployerResource, } from "./resources/api-deployer.js";
 export { ApiServicesResource, } from "./resources/api-services.js";
 export { ApplicationsResource, } from "./resources/applications.js";
@@ -20,10 +21,13 @@ export { InsightsResource, } from "./resources/insights.js";
 export { computeNextPollDelayMs, type JobBuildAndWaitOptions, type JobBuildOptions, type JobBuildTarget, type JobBuildTargetType, type JobLogFilter, type JobLogProgress, type JobLogSummary, JobsResource, parseJobLogProgress, } from "./resources/jobs.js";
 export { MeaningsResource, } from "./resources/meanings.js";
 export { MetricsResource, } from "./resources/metrics.js";
+export * from "./resources/ml-tasks.js";
+export * from "./resources/model-evaluation-stores.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { ProjectLibraryResource, } from "./resources/project-library.js";
 export { type FlowMapResult, ProjectsResource, } from "./resources/projects.js";
 export { type RecipeCloneOptions, type RecipeCloneResult, type RecipeGraphReference, type RecipeGraphValidationResult, type RecipeRunOptions, type RecipeRunOutput, type RecipeRunResult, RecipesResource, } from "./resources/recipes.js";
+export * from "./resources/saved-models.js";
 export { normalizeScenarioUpdateData, SCENARIO_CANONICAL_EDITABLE_FIELDS, type ScenarioFieldChange, type ScenarioFieldMismatch, type ScenarioScriptRunResult, ScenariosResource, type ScenarioUpdateNormalization, type ScenarioUpdatePreview, scenarioUpdatePreview, type ScenarioUpdateResult, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { StatisticsResource, } from "./resources/statistics.js";

package/dist/src/index.js

@@ -6,6 +6,7 @@ export { getConfigDir, getCredentialsPath, loadCredentials, saveCredentials, } f
 // Errors
 export { ClientValidationError, DataikuError, } from "./errors.js";
 // Resources (for advanced use / extension)
+export * from "./resources/analyses.js";
 export { ApiDeployerResource, } from "./resources/api-deployer.js";
 export { ApiServicesResource, } from "./resources/api-services.js";
 export { ApplicationsResource, } from "./resources/applications.js";
@@ -24,10 +25,13 @@ export { InsightsResource, } from "./resources/insights.js";
 export { computeNextPollDelayMs, JobsResource, parseJobLogProgress, } from "./resources/jobs.js";
 export { MeaningsResource, } from "./resources/meanings.js";
 export { MetricsResource, } from "./resources/metrics.js";
+export * from "./resources/ml-tasks.js";
+export * from "./resources/model-evaluation-stores.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { ProjectLibraryResource, } from "./resources/project-library.js";
 export { ProjectsResource, } from "./resources/projects.js";
 export { RecipesResource, } from "./resources/recipes.js";
+export * from "./resources/saved-models.js";
 export { normalizeScenarioUpdateData, SCENARIO_CANONICAL_EDITABLE_FIELDS, ScenariosResource, scenarioUpdatePreview, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { StatisticsResource, } from "./resources/statistics.js";

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

@@ -0,0 +1,34 @@
+import { BaseResource } from "./base.js";
+export interface AnalysisListItem extends Record<string, unknown> {
+    id?: string;
+    analysisId?: string;
+    name?: string;
+    inputDataset?: string;
+}
+export interface AnalysisDefinition extends Record<string, unknown> {
+    id?: string;
+    analysisId?: string;
+    name?: string;
+    projectKey?: string;
+    inputDataset?: string;
+    script?: Record<string, unknown>;
+}
+export interface AnalysisCreateOptions {
+    inputDataset: string;
+    projectKey?: string;
+}
+export interface AnalysisCreateResult extends Record<string, unknown> {
+    id?: string;
+    analysisId?: string;
+}
+export declare class AnalysesResource extends BaseResource {
+    /** List visual analyses in a project. */
+    list(projectKey?: string): Promise<AnalysisListItem[]>;
+    /** Get the definition of a visual analysis. */
+    get(analysisId: string, projectKey?: string): Promise<AnalysisDefinition>;
+    /** Create a visual analysis for an input dataset. */
+    create(opts: AnalysisCreateOptions): Promise<AnalysisCreateResult>;
+    /** Delete a visual analysis. */
+    delete(analysisId: string, projectKey?: string): Promise<void>;
+    private analysisPath;
+}

package/dist/src/resources/analyses.js

@@ -0,0 +1,31 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+export class AnalysesResource extends BaseResource {
+    /** List visual analyses in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/lab/`);
+    }
+    /** Get the definition of a visual analysis. */
+    async get(analysisId, projectKey) {
+        return this.client.get(`${this.analysisPath(analysisId, projectKey)}/`);
+    }
+    /** Create a visual analysis for an input dataset. */
+    async create(opts) {
+        const inputDataset = requireNonEmpty(opts.inputDataset, "inputDataset");
+        return this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/lab/`, { inputDataset, });
+    }
+    /** Delete a visual analysis. */
+    async delete(analysisId, projectKey) {
+        await this.client.del(`${this.analysisPath(analysisId, projectKey)}/`);
+    }
+    analysisPath(analysisId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(analysisId, "analysisId"));
+        return `/public/api/projects/${this.enc(projectKey)}/lab/${id}`;
+    }
+}

package/dist/src/resources/api-services.d.ts

@@ -19,6 +19,8 @@ export declare class ApiServicesResource extends BaseResource {
     getSettings(serviceId: string, projectKey?: string): Promise<Record<string, unknown>>;
     /** Save API service settings. */
     saveSettings(serviceId: string, body: Record<string, unknown>, projectKey?: string): Promise<ApiServiceActionResult>;
+    /** Add a standard prediction endpoint backed by a saved model. */
+    addPredictionEndpoint(serviceId: string, endpointId: string, savedModelId: string, projectKey?: string): Promise<ApiServiceActionResult>;
     /** List deployable packages for an API service. */
     listPackages(serviceId: string, projectKey?: string): Promise<ApiServicePackageListItem[]>;
     /** Get an API service package summary. */

package/dist/src/resources/api-services.js

@@ -16,6 +16,16 @@ export class ApiServicesResource extends BaseResource {
     async saveSettings(serviceId, body, projectKey) {
         return this.client.put(`${this.servicePath(serviceId, projectKey)}/settings`, body);
     }
+    /** Add a standard prediction endpoint backed by a saved model. */
+    async addPredictionEndpoint(serviceId, endpointId, savedModelId, projectKey) {
+        const settings = await this.getSettings(serviceId, projectKey);
+        const endpoints = Array.isArray(settings.endpoints) ? settings.endpoints : [];
+        settings.endpoints = [
+            ...endpoints,
+            { id: endpointId, type: "STD_PREDICTION", modelRef: savedModelId, },
+        ];
+        return this.saveSettings(serviceId, settings, projectKey);
+    }
     /** List deployable packages for an API service. */
     async listPackages(serviceId, projectKey) {
         return this.client.get(`${this.servicePath(serviceId, projectKey)}/packages`);

package/dist/src/resources/datasets.js

@@ -1,5 +1,5 @@
-import { createWriteStream, } from "node:fs";
-import { resolve, } from "node:path";
+import * as fs from "node:fs";
+import * as nodePath from "node:path";
 import { Readable, Transform, } from "node:stream";
 import { pipeline, } from "node:stream/promises";
 import { createGzip, } from "node:zlib";
@@ -297,6 +297,7 @@ function buildDatasetCreateBody(opts) {
 }
 const DATASET_CLONE_PARAM_KEYS = [
     "connection",
+    "uploadConnection",
     "path",
     "table",
     "schema",
@@ -418,8 +419,8 @@ export class DatasetsResource extends BaseResource {
         const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/datasets/${dsEnc}/data/?format=tsv-excel-header&limit=${limit + 1}`);
         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`);
+            ? nodePath.resolve(opts.outputPath)
+            : nodePath.resolve(opts?.outputPath ?? process.cwd(), `${safeDatasetName}.csv.gz`);
         const onHeader = opts?.validateColumns
             ? (headerRow) => {
                 const warnings = validateStreamColumns(headerRow, opts.validateColumns);
@@ -432,7 +433,8 @@ export class DatasetsResource extends BaseResource {
         const stats = { rows: 0, truncated: false, };
         const nodeStream = Readable.fromWeb(res.body);
         const csvTransform = tsvToCsvTransform(limit, stats, onHeader);
-        const fileOut = createWriteStream(filePath);
+        fs.mkdirSync(nodePath.dirname(filePath), { recursive: true, });
+        const fileOut = fs.createWriteStream(filePath);
         if (shouldGzip) {
             const gzip = createGzip();
             await pipeline(nodeStream, csvTransform, gzip, fileOut);

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

@@ -0,0 +1,91 @@
+import { BaseResource } from "./base.js";
+export type MlTaskType = "PREDICTION" | "CLUSTERING";
+export interface MlTaskCreateOptions {
+    analysisId: string;
+    taskType: MlTaskType;
+    targetVariable?: string;
+    predictionType?: string;
+    backendType?: string;
+    guessPolicy?: string;
+    projectKey?: string;
+}
+export interface MlTaskCreateResult extends Record<string, unknown> {
+    analysisId?: string;
+    mlTaskId?: string;
+}
+export interface MlTaskFullModelId extends Record<string, unknown> {
+    id?: string;
+    fullModelId?: {
+        sessionId?: string;
+        [key: string]: unknown;
+    };
+}
+export interface MlTaskStatus extends Record<string, unknown> {
+    guessing?: boolean;
+    training?: boolean;
+    fullModelIds?: MlTaskFullModelId[];
+}
+export interface MlTaskSettings extends Record<string, unknown> {
+    taskType?: MlTaskType;
+    predictionType?: string;
+}
+export interface MlTaskActionResult extends Record<string, unknown> {
+    message?: string;
+}
+export interface MlTaskTrainOptions {
+    analysisId: string;
+    mlTaskId: string;
+    sessionName?: string;
+    sessionDescription?: string;
+    runQueue?: boolean;
+    wait?: boolean;
+    projectKey?: string;
+}
+export interface MlTaskTrainingSession extends Record<string, unknown> {
+    sessionId: string;
+}
+export interface MlTaskTrainCompletedResult extends Record<string, unknown> {
+    sessionId: string;
+    trainedModelIds: string[];
+}
+export type MlTaskTrainResult = MlTaskTrainingSession | MlTaskTrainCompletedResult;
+export interface MlTrainedModelDetails extends Record<string, unknown> {
+    id?: string;
+    algorithm?: string;
+    predictionType?: string;
+}
+export interface MlTaskDeployOptions {
+    analysisId: string;
+    mlTaskId: string;
+    modelId: string;
+    trainDatasetRef: string;
+    testDatasetRef?: string;
+    modelName: string;
+    redoOptimization?: boolean;
+    projectKey?: string;
+}
+export interface MlTaskDeployResult extends Record<string, unknown> {
+    savedModelId?: string;
+    trainRecipeName?: string;
+}
+export declare class MlTasksResource extends BaseResource {
+    /** Create a prediction or clustering task in an existing visual analysis. */
+    create(opts: MlTaskCreateOptions): Promise<MlTaskCreateResult>;
+    /** Get the current guessing, training, and trained-model status of a task. */
+    status(analysisId: string, mlTaskId: string, projectKey?: string): Promise<MlTaskStatus>;
+    /** Get the editable settings of an ML task. */
+    getSettings(analysisId: string, mlTaskId: string, projectKey?: string): Promise<MlTaskSettings>;
+    /** Save the full settings object of an ML task. */
+    saveSettings(analysisId: string, mlTaskId: string, settings: MlTaskSettings, projectKey?: string): Promise<MlTaskActionResult | undefined>;
+    /** Start training, optionally waiting for the task to finish. */
+    train(opts: MlTaskTrainOptions): Promise<MlTaskTrainResult>;
+    /** List identifiers for every trained model currently present on the task. */
+    listTrainedModels(analysisId: string, mlTaskId: string, projectKey?: string): Promise<string[]>;
+    /** Get full details for a trained model. */
+    trainedModelDetails(analysisId: string, mlTaskId: string, modelId: string, projectKey?: string): Promise<MlTrainedModelDetails>;
+    /** Deploy a trained model to the Flow as a saved model and training recipe. */
+    deployToFlow(opts: MlTaskDeployOptions): Promise<MlTaskDeployResult>;
+    /** Delete an ML task and its trained models. */
+    delete(analysisId: string, mlTaskId: string, projectKey?: string): Promise<void>;
+    private taskPath;
+}

package/dist/src/resources/ml-tasks.js

@@ -0,0 +1,130 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+const TRAIN_POLL_INTERVAL_MS = 5_000;
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+function delay(ms) {
+    const { promise, resolve, } = Promise.withResolvers();
+    setTimeout(resolve, ms);
+    return promise;
+}
+function modelIdsFromStatus(status) {
+    if (!Array.isArray(status.fullModelIds))
+        return [];
+    const modelIds = [];
+    for (const model of status.fullModelIds) {
+        if (typeof model?.id === "string" && model.id.length > 0)
+            modelIds.push(model.id);
+    }
+    return modelIds;
+}
+export class MlTasksResource extends BaseResource {
+    /** Create a prediction or clustering task in an existing visual analysis. */
+    async create(opts) {
+        if (opts.taskType !== "PREDICTION" && opts.taskType !== "CLUSTERING") {
+            throw new UsageError("taskType must be PREDICTION or CLUSTERING.", "invalid_enum");
+        }
+        if (opts.taskType === "PREDICTION"
+            && (typeof opts.targetVariable !== "string" || opts.targetVariable.trim().length === 0)) {
+            throw new UsageError("targetVariable is required for PREDICTION ML tasks.", "missing_required_arg");
+        }
+        const analysisId = encodeURIComponent(requireNonEmpty(opts.analysisId, "analysisId"));
+        const backendType = opts.backendType ?? "PY_MEMORY";
+        const guessPolicy = opts.guessPolicy
+            ?? (opts.taskType === "CLUSTERING" ? "KMEANS" : "DEFAULT");
+        requireNonEmpty(backendType, "backendType");
+        requireNonEmpty(guessPolicy, "guessPolicy");
+        if (opts.targetVariable !== undefined)
+            requireNonEmpty(opts.targetVariable, "targetVariable");
+        if (opts.predictionType !== undefined)
+            requireNonEmpty(opts.predictionType, "predictionType");
+        return this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/lab/${analysisId}/models/`, {
+            taskType: opts.taskType,
+            ...(opts.targetVariable !== undefined
+                ? { targetVariable: opts.targetVariable, }
+                : {}),
+            ...(opts.predictionType !== undefined
+                ? { predictionType: opts.predictionType, }
+                : {}),
+            backendType,
+            guessPolicy,
+        });
+    }
+    /** Get the current guessing, training, and trained-model status of a task. */
+    async status(analysisId, mlTaskId, projectKey) {
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/status`);
+    }
+    /** Get the editable settings of an ML task. */
+    async getSettings(analysisId, mlTaskId, projectKey) {
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/settings`);
+    }
+    /** Save the full settings object of an ML task. */
+    async saveSettings(analysisId, mlTaskId, settings, projectKey) {
+        if (settings === null || typeof settings !== "object" || Array.isArray(settings)) {
+            throw new UsageError("settings must be an object.", "validation_failed");
+        }
+        return this.client.post(`${this.taskPath(analysisId, mlTaskId, projectKey)}/settings`, settings);
+    }
+    /** Start training, optionally waiting for the task to finish. */
+    async train(opts) {
+        if (opts.sessionName !== undefined)
+            requireNonEmpty(opts.sessionName, "sessionName");
+        if (opts.sessionDescription !== undefined) {
+            requireNonEmpty(opts.sessionDescription, "sessionDescription");
+        }
+        const taskPath = this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        const session = await this.client.post(`${taskPath}/train`, {
+            sessionName: opts.sessionName,
+            sessionDescription: opts.sessionDescription,
+            runQueue: opts.runQueue ?? false,
+        });
+        if (opts.wait !== true)
+            return session;
+        let status = await this.status(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        while (status.training !== false) {
+            await delay(TRAIN_POLL_INTERVAL_MS);
+            status = await this.status(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        }
+        return {
+            sessionId: session.sessionId,
+            trainedModelIds: modelIdsFromStatus(status),
+        };
+    }
+    /** List identifiers for every trained model currently present on the task. */
+    async listTrainedModels(analysisId, mlTaskId, projectKey) {
+        return modelIdsFromStatus(await this.status(analysisId, mlTaskId, projectKey));
+    }
+    /** Get full details for a trained model. */
+    async trainedModelDetails(analysisId, mlTaskId, modelId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(modelId, "modelId"));
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/models/${id}/details`);
+    }
+    /** Deploy a trained model to the Flow as a saved model and training recipe. */
+    async deployToFlow(opts) {
+        const modelId = encodeURIComponent(requireNonEmpty(opts.modelId, "modelId"));
+        const trainDatasetRef = requireNonEmpty(opts.trainDatasetRef, "trainDatasetRef");
+        const modelName = requireNonEmpty(opts.modelName, "modelName");
+        if (opts.testDatasetRef !== undefined) {
+            requireNonEmpty(opts.testDatasetRef, "testDatasetRef");
+        }
+        return this.client.post(`${this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey)}/models/${modelId}/actions/deployToFlow`, {
+            trainDatasetRef,
+            testDatasetRef: opts.testDatasetRef,
+            modelName,
+            redoOptimization: opts.redoOptimization ?? true,
+        });
+    }
+    /** Delete an ML task and its trained models. */
+    async delete(analysisId, mlTaskId, projectKey) {
+        await this.client.del(`${this.taskPath(analysisId, mlTaskId, projectKey)}/`);
+    }
+    taskPath(analysisId, mlTaskId, projectKey) {
+        const analysis = encodeURIComponent(requireNonEmpty(analysisId, "analysisId"));
+        const task = encodeURIComponent(requireNonEmpty(mlTaskId, "mlTaskId"));
+        return `/public/api/projects/${this.enc(projectKey)}/models/lab/${analysis}/${task}`;
+    }
+}