dataiku-sdk 3.2.0 → 3.3.0

package/dist/src/resources/project-git.js

@@ -1,5 +1,7 @@
-import { ClientValidationError, DataikuError, } from "../errors.js";
+import { ClientValidationError, } from "../errors.js";
 import { ProjectGitActionResultSchema, ProjectGitDiffResultSchema, ProjectGitFutureResponseSchema, ProjectGitFutureStateSchema, ProjectGitLibrariesSchema, ProjectGitLogResultSchema, ProjectGitRemoteSchema, ProjectGitStatusSchema, ProjectGitTagsSchema, } from "../schemas.js";
+import { computeNextPollDelayMs, isRequestDeadlineError, } from "../utils/polling.js";
+import { sanitizeErrorSecrets, } from "../utils/secret-sanitize.js";
 import { BaseResource, } from "./base.js";
 /**
  * The per-project Git routes exist only under the dataikuapi base, not under
@@ -89,28 +91,10 @@ function validatedRepository(repository, field) {
     return candidate;
 }
 /** Replace every exact occurrence of a secret so echoed errors cannot leak it. */
-function redactSecrets(text, secrets) {
-    let result = text;
-    for (const secret of secrets) {
-        if (secret !== undefined && secret !== "") {
-            result = result.split(secret).join("[redacted]");
-        }
-    }
-    return result;
-}
-/**
- * Strip a password that a server misconfiguration may have echoed from an
- * error response. `DataikuError.message` was built at construction, so the
- * raw body, the message, and the stack all need scrubbing.
- */
 function scrubErrorSecrets(error, secrets) {
-    if (!(error instanceof DataikuError) || secrets.length === 0)
+    if (secrets.length === 0)
         return;
-    error.body = redactSecrets(error.body, secrets);
-    error.message = redactSecrets(error.message, secrets);
-    if (typeof error.stack === "string") {
-        error.stack = redactSecrets(error.stack, secrets);
-    }
+    sanitizeErrorSecrets(error, { sensitiveKeys: {}, secrets, });
 }
 function describeFutureFailure(error) {
     if (error === undefined || error === null)
@@ -129,6 +113,31 @@ function describeFutureFailure(error) {
     return String(error);
 }
 /* ------------------------------------------------------------------ */
+/**
+ * DSS answers the lib-git-refs listing as an object map of attached external
+ * libraries keyed by target path alongside code-library metadata (observed
+ * raw on DSS 15: `{gitReferences, pythonPath, rsrcPath,
+ * importLibrariesFromProjects}`), while the official Python client and this
+ * resource's typed contract expose a plain array. Normalize the map into
+ * entries, preserving each key as the library's `localTargetPath`; a bare
+ * array passes through untouched.
+ */
+function normalizeLibraryList(raw) {
+    if (Array.isArray(raw) || raw === undefined || raw === null)
+        return raw ?? [];
+    if (typeof raw !== "object")
+        return raw;
+    const record = raw;
+    const refs = record["gitReferences"];
+    if (refs === undefined || refs === null || typeof refs !== "object" || Array.isArray(refs)) {
+        return raw;
+    }
+    return Object.entries(refs).map(([localTargetPath, spec,]) => ({
+        localTargetPath,
+        ...(typeof spec === "object" && spec !== null ? spec : {}),
+    }));
+}
+/* ------------------------------------------------------------------ */
 /*  Resource                                                          */
 /* ------------------------------------------------------------------ */
 export class ProjectGitResource extends BaseResource {
@@ -287,7 +296,7 @@ export class ProjectGitResource extends BaseResource {
     /* ---- external libraries (async futures) ---- */
     async listLibraries(projectKey) {
         const raw = await this.request("GET", `${this.libraryPath(projectKey)}/`);
-        return this.client.safeParse(ProjectGitLibrariesSchema, raw ?? [], "projectGit.listLibraries");
+        return this.client.safeParse(ProjectGitLibrariesSchema, normalizeLibraryList(raw), "projectGit.listLibraries");
     }
     /** Attach an external Git library. Runs as a DSS future. */
     async addLibrary(projectKey, options) {
@@ -355,7 +364,7 @@ export class ProjectGitResource extends BaseResource {
      * what polling loops want; the default consumes it like the Python client.
      */
     async getFutureState(jobId, options = {}) {
-        const raw = await this.request("GET", `/futures/${encodeURIComponent(jobId)}${this.query({ peek: options.peek === true, })}`);
+        const raw = await this.request("GET", `/futures/${encodeURIComponent(jobId)}${this.query({ peek: options.peek === true, })}`, undefined, [], { timeoutMs: options.timeoutMs, });
         return this.client.safeParse(ProjectGitFutureStateSchema, raw ?? {}, "projectGit.getFutureState");
     }
     /** Abort a running future. */
@@ -376,10 +385,36 @@ export class ProjectGitResource extends BaseResource {
         if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
             throw new ClientValidationError("timeoutMs must be a finite non-negative number.");
         }
+        // Adaptive backoff applies only when the caller did not pin an exact
+        // interval; an explicit pollIntervalMs is an exact contract.
+        const adaptiveEnabled = options.pollIntervalMs === undefined;
+        let pollCount = 0;
         const startedAt = Date.now();
         while (true) {
             // Unlike peek state, the ordinary state includes the completed result.
-            const state = await this.getFutureState(jobId, { peek: false, });
+            // One state observation always happens, even when the budget is
+            // already spent (the poll precedes the deadline check); only the
+            // requests issued while budget remains are bounded by the remaining
+            // time, so a stalled endpoint can never defeat the caller's deadline.
+            const remainingMs = timeoutMs - (Date.now() - startedAt);
+            pollCount += 1;
+            let state;
+            try {
+                state = await this.getFutureState(jobId, remainingMs > 0
+                    ? {
+                        peek: false,
+                        timeoutMs: remainingMs,
+                    }
+                    : { peek: false, });
+            }
+            catch (error) {
+                // The poll budget ran out mid-request: report the documented
+                // timeout failure instead of letting the transport deadline
+                // error escape.
+                if (!isRequestDeadlineError(error, startedAt + timeoutMs))
+                    throw error;
+                throw new Error(`Timed out after ${String(Date.now() - startedAt)}ms waiting for Dataiku future ${jobId}`, { cause: error, });
+            }
             const failure = describeFutureFailure(state.error);
             if (failure !== undefined) {
                 throw new Error(`Dataiku future ${jobId} failed: ${failure}`);
@@ -395,13 +430,18 @@ export class ProjectGitResource extends BaseResource {
             if (state.alive === false) {
                 throw new Error(`Dataiku future ${jobId} ended without producing a result`);
             }
-            // Only the remaining budget is slept, so a caller's deadline is never
-            // overshot by a whole poll interval.
             const elapsedMs = Date.now() - startedAt;
             if (elapsedMs >= timeoutMs) {
                 throw new Error(`Timed out after ${String(elapsedMs)}ms waiting for Dataiku future ${jobId}`);
             }
-            await sleep(Math.min(pollIntervalMs, timeoutMs - elapsedMs));
+            const nextDelayMs = computeNextPollDelayMs({
+                pollCount,
+                baseIntervalMs: pollIntervalMs,
+                adaptiveEnabled,
+            });
+            // Only the remaining budget is slept, so a caller's deadline is never
+            // overshot by a whole interval.
+            await sleep(Math.min(nextDelayMs, timeoutMs - elapsedMs));
         }
     }
     /* ---- private ---- */
@@ -424,22 +464,9 @@ export class ProjectGitResource extends BaseResource {
         const queryString = search.toString();
         return queryString === "" ? "" : `?${queryString}`;
     }
-    async request(method, path, body, secrets = []) {
-        const transport = this.client;
-        const init = {
-            method,
-            headers: {
-                // The Git routes are only reachable with dataikuapi-style Basic auth:
-                // API key as the username, empty password.
-                Authorization: `Basic ${Buffer.from(`${transport.apiKey}:`, "utf8").toString("base64")}`,
-                Accept: "application/json",
-                "Content-Type": "application/json",
-            },
-        };
-        if (body !== undefined)
-            init.body = JSON.stringify(body);
+    async request(method, path, body, secrets = [], opts = {}) {
         try {
-            const res = await transport.fetchWithRetry(`${transport.baseUrl}${GIT_API_BASE}${path}`, init);
+            const res = await this.client.requestGit(method, `${GIT_API_BASE}${path}`, body, opts.timeoutMs === undefined ? undefined : Date.now() + opts.timeoutMs);
             const text = await res.text();
             if (text.trim() === "")
                 return undefined;

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

@@ -147,7 +147,6 @@ export declare class ProjectLibraryResource extends BaseResource {
     /** Move a project code-library file or folder into another library folder. */
     move(path: string, destinationFolderPath: string, projectKey?: string): Promise<void>;
     private contentsPath;
-    private postRawBody;
     private alreadyExistsError;
     private assertLibraryFileAbsent;
 }

package/dist/src/resources/project-library.js

@@ -403,7 +403,7 @@ export class ProjectLibraryResource extends BaseResource {
         }
         const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : content;
         const sha256 = sha256Hex(bytes);
-        await this.postRawBody(this.contentsPath(valid, projectKey), content);
+        await this.client.postRawBody(this.contentsPath(valid, projectKey), content);
         return {
             path: valid,
             bytes: bytes.length,
@@ -518,22 +518,6 @@ export class ProjectLibraryResource extends BaseResource {
         const projectKeyPart = this.enc(projectKey);
         return `/public/api/projects/${projectKeyPart}/libraries/contents/${encodeLibraryPath(path)}`;
     }
-    async postRawBody(path, body) {
-        // DSS library writes use dataikuapi's raw_body; route through the client's
-        // transport so auth, retries, TLS options, and DSS error handling stay aligned.
-        // BodyInit rejects plain Uint8Array views, so non-Buffer bytes are copied
-        // into a Buffer (an ArrayBufferView BodyInit accepts).
-        const payload = body instanceof Uint8Array && !(body instanceof Buffer)
-            ? Buffer.from(body.buffer, body.byteOffset, body.byteLength)
-            : body;
-        const rawClient = this.client;
-        const res = await rawClient.fetchWithRetry(`${rawClient.baseUrl}${path}`, {
-            method: "POST",
-            headers: rawClient.getAnyHeaders(),
-            body: payload,
-        });
-        await res.text();
-    }
     alreadyExistsError(path) {
         return new ClientValidationError(`Project library item "${path}" already exists.`, "validation_failed", "Refuse to overwrite an existing item; delete it first, or use the create-or-replace update to replace an existing file.", { path, });
     }

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

@@ -1,4 +1,4 @@
-import type { FlowMapOptions, ProjectDetails, ProjectMetadata, ProjectSummary } from "../schemas.js";
+import type { FlowMapOptions, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectTags } from "../schemas.js";
 import type { AnalyzedFlowMap, FlowMapRendering } from "../utils/flow-analysis.js";
 import { BaseResource } from "./base.js";
 interface FlowMapTruncationSummary {
@@ -124,6 +124,24 @@ export declare class ProjectsResource extends BaseResource {
     get(projectKey?: string): Promise<ProjectDetails>;
     /** Get metadata (tags, custom fields, checklists) for a project. */
     metadata(projectKey?: string): Promise<ProjectMetadata>;
+    /**
+     * Replace project metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the project.
+     */
+    setMetadata(projectKey: string | undefined, metadata: ProjectMetadata): Promise<void>;
+    /** Get project-level tags (tag name → {color?}). */
+    tags(projectKey?: string): Promise<ProjectTags>;
+    /**
+     * Replace project-level tags with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole tags dictionary: pass a tags object
+     * obtained from {@link tags}, edit it, and send it back — tags absent from
+     * the payload are removed from the project.
+     */
+    setTags(projectKey: string | undefined, tags: ProjectTags): Promise<void>;
     /** Get the raw flow graph for a project. */
     flow(projectKey?: string): Promise<unknown>;
     /** Compute a stable fingerprint of flow nodes and edges, excluding visual metadata. */

package/dist/src/resources/projects.js

@@ -1,6 +1,6 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { writeResponseToFile, } from "../utils/response-file.js";
-import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, } from "../schemas.js";
+import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectTagsSchema, } from "../schemas.js";
 import { analyzeFlowMap, flowTopologyFingerprint, renderFlowMap, } from "../utils/flow-analysis.js";
 import { normalizeFlowGraph, } from "../utils/flow-map.js";
 import { assertImportableProjectArchive, } from "../utils/project-archive.js";
@@ -302,6 +302,32 @@ export class ProjectsResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${enc}/metadata`);
         return this.client.safeParse(ProjectMetadataSchema, raw, "projects.metadata");
     }
+    /**
+     * Replace project metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the project.
+     */
+    async setMetadata(projectKey, metadata) {
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/metadata`, metadata);
+    }
+    /** Get project-level tags (tag name → {color?}). */
+    async tags(projectKey) {
+        const enc = this.enc(projectKey);
+        const raw = await this.client.get(`/public/api/projects/${enc}/tags`);
+        return this.client.safeParse(ProjectTagsSchema, raw, "projects.tags");
+    }
+    /**
+     * Replace project-level tags with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole tags dictionary: pass a tags object
+     * obtained from {@link tags}, edit it, and send it back — tags absent from
+     * the payload are removed from the project.
+     */
+    async setTags(projectKey, tags) {
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/tags`, tags);
+    }
     /** Get the raw flow graph for a project. */
     async flow(projectKey) {
         const enc = this.enc(projectKey);

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

@@ -1,4 +1,4 @@
-import type { BuildMode, JobWaitResult, RecipeCreateOptions, RecipeCreateResult, RecipeSummary } from "../schemas.js";
+import type { BuildMode, JobWaitResult, ProjectMetadata, RecipeCreateOptions, RecipeCreateResult, RecipeSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
 import type { JobBuildTarget, JobBuildTargetType, JobLogFilter, JobLogSummary } from "./jobs.js";
 export interface RecipeRunOutput extends JobBuildTarget {
@@ -68,6 +68,20 @@ export interface RecipeCloneResult {
 export declare class RecipesResource extends BaseResource {
     /** List all recipes in a project. */
     list(projectKey?: string): Promise<RecipeSummary[]>;
+    /** Get recipe metadata (label, tags, description, custom fields). */
+    metadata(recipeName: string, opts?: {
+        projectKey?: string;
+    }): Promise<ProjectMetadata>;
+    /**
+     * Replace recipe metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the recipe.
+     */
+    setMetadata(recipeName: string, metadata: ProjectMetadata, opts?: {
+        projectKey?: string;
+    }): Promise<void>;
     /**
      * Get a recipe definition (and optionally its payload).
      * Returns the raw API response shape: `{ recipe, payload }`.

package/dist/src/resources/recipes.js

@@ -1,7 +1,7 @@
 import { writeFile, } from "node:fs/promises";
 import { resolve, } from "node:path";
 import { DataikuError, } from "../errors.js";
-import { RecipeSummaryArraySchema, } from "../schemas.js";
+import { ProjectMetadataSchema, RecipeSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
@@ -95,6 +95,8 @@ function normalizeRecipeOutputType(value) {
         return "DATASET";
     if (normalized === "MANAGED_FOLDER" || normalized === "FOLDER")
         return "MANAGED_FOLDER";
+    if (normalized === "MODEL_EVALUATION_STORE")
+        return "MODEL_EVALUATION_STORE";
     return undefined;
 }
 function recipeOutputItems(recipe) {
@@ -116,7 +118,12 @@ function recipeOutputItems(recipe) {
             if (seen.has(seenKey))
                 continue;
             seen.add(seenKey);
-            const type = normalizeRecipeOutputType(item?.type ?? item?.targetType ?? item?.objectType);
+            // The evaluation recipe's "evaluationStore" role targets a model
+            // evaluation store even when the item carries no explicit type
+            // (recipe.py EvaluationRecipeCreator.with_output_evaluation_store);
+            // the store is a valid job target (run object_type_map).
+            const type = normalizeRecipeOutputType(item?.type ?? item?.targetType ?? item?.objectType)
+                ?? (role === "evaluationStore" ? "MODEL_EVALUATION_STORE" : undefined);
             result.push({
                 ref,
                 role,
@@ -292,6 +299,25 @@ export class RecipesResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${enc}/recipes/`);
         return this.client.safeParse(RecipeSummaryArraySchema, raw, "recipes.list");
     }
+    /** Get recipe metadata (label, tags, description, custom fields). */
+    async metadata(recipeName, opts) {
+        const enc = this.enc(opts?.projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        const raw = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}/metadata`);
+        return this.client.safeParse(ProjectMetadataSchema, raw, "recipes.metadata");
+    }
+    /**
+     * Replace recipe metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the recipe.
+     */
+    async setMetadata(recipeName, metadata, opts) {
+        const enc = this.enc(opts?.projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        await this.client.putVoid(`/public/api/projects/${enc}/recipes/${rnEnc}/metadata`, metadata);
+    }
     /**
      * Get a recipe definition (and optionally its payload).
      * Returns the raw API response shape: `{ recipe, payload }`.
@@ -320,11 +346,13 @@ export class RecipesResource extends BaseResource {
         const { recipe, } = await this.get(recipeName, { projectKey: pk, });
         const inputItems = recipeInputItems(recipe);
         const outputItems = recipeOutputItems(recipe);
-        const [datasets, folders,] = await Promise.all([
+        const [datasets, folders, stores,] = await Promise.all([
             this.client.datasets.list(pk),
             this.client.folders.list(pk),
+            this.client.modelEvaluationStores.list(pk),
         ]);
         const datasetNames = new Set(datasets.map((dataset) => dataset.name));
+        const storeIds = new Set(stores.map((store) => store.id));
         const folderIdByRef = new Map();
         for (const folder of folders) {
             folderIdByRef.set(folder.id, folder.id);
@@ -337,6 +365,15 @@ export class RecipesResource extends BaseResource {
             if (item.type === "DATASET") {
                 return { ref: item.ref, role: item.role, type: "DATASET", exists: isDataset, id: item.ref, };
             }
+            if (item.type === "MODEL_EVALUATION_STORE") {
+                return {
+                    ref: item.ref,
+                    role: item.role,
+                    type: "MODEL_EVALUATION_STORE",
+                    exists: storeIds.has(item.ref),
+                    id: item.ref,
+                };
+            }
             if (item.type === "MANAGED_FOLDER") {
                 return {
                     ref: item.ref,
@@ -420,6 +457,19 @@ export class RecipesResource extends BaseResource {
                     partition: opts?.partition,
                 };
             }
+            if (item.type === "MODEL_EVALUATION_STORE") {
+                // The store id is the target id; evaluation builds into the store
+                // exactly like the official client (recipe.run maps
+                // COMPUTABLE_MODEL_EVALUATION_STORE -> MODEL_EVALUATION_STORE).
+                return {
+                    ref: item.ref,
+                    role: item.role,
+                    id: item.ref,
+                    type: "MODEL_EVALUATION_STORE",
+                    projectKey: pk,
+                    partition: opts?.partition,
+                };
+            }
             const folderId = folderIdByRef.get(item.ref);
             if (item.type === "MANAGED_FOLDER") {
                 return {
@@ -632,10 +682,22 @@ export class RecipesResource extends BaseResource {
                 }
             }
         };
+        let finalRecipeName;
+        // DSS renames some recipe types server-side (e.g. prediction_scoring
+        // becomes "score_<inputDataset>") and documents the creation response as
+        // the final unique name: Body {"name": "recipe1"} ("Returns the final
+        // unique name of the recipe"). The response name is the contract —
+        // falling back to the requested name would mask a missing/invalid
+        // receipt, so a body without it is an error.
         try {
             if (rawConnection)
                 await provisionOutputDatasets();
-            await createRecipe();
+            const created = await createRecipe();
+            const receivedName = asString(created?.["name"]);
+            if (!receivedName) {
+                throw new Error('DSS create-recipe response did not include the final recipe name (documented body: {"name": ...}).');
+            }
+            finalRecipeName = receivedName;
         }
         catch (error) {
             if (!shouldRetryRecipeCreateWithOutputProvisioning(error)) {
@@ -643,7 +705,12 @@ export class RecipesResource extends BaseResource {
             }
             usedOutputProvisioningFallback = true;
             await provisionOutputDatasets();
-            await createRecipe();
+            const retryCreated = await createRecipe();
+            const retryName = asString(retryCreated?.["name"]);
+            if (!retryName) {
+                throw new Error('DSS create-recipe response did not include the final recipe name (documented body: {"name": ...}).', { cause: error, });
+            }
+            finalRecipeName = retryName;
         }
         // For sync recipes (a 1:1 copy) DSS does not propagate schema on build, so a
         // schemaless dataset output silently builds to an empty dataset. Copy the
@@ -781,7 +848,7 @@ export class RecipesResource extends BaseResource {
             }
         }
         return {
-            recipeName: name,
+            recipeName: finalRecipeName,
             type,
             createdDatasets,
             joinConfigured,

package/dist/src/resources/saved-models.d.ts

@@ -24,18 +24,151 @@ export interface SavedModelVersionDetails extends Record<string, unknown> {
 export interface SavedModelActionResult extends Record<string, unknown> {
     message?: string;
 }
+/**
+ * Body of POST /projects/{pkey}/savedmodels/ (official Python client
+ * `create_mlflow_model` / `create_external_model`; the REST reference's
+ * `/savedmodels/create-external` path returns 405 on DSS 15.0.1).
+ * `savedModelType` is only "MLFLOW_PYFUNC" or "PROXY_MODEL"; `proxyModelConfiguration`
+ * carries the protocol settings for PROXY_MODEL creation (sagemaker, azure-ml,
+ * vertex-ai, databricks — per the official Python client `create_external_model`).
+ */
+export interface SavedModelCreateRequest extends Record<string, unknown> {
+    savedModelType: "MLFLOW_PYFUNC" | "PROXY_MODEL";
+    name: string;
+    predictionType?: "BINARY_CLASSIFICATION" | "MULTICLASS" | "REGRESSION" | null;
+    /** PROXY_MODEL only: e.g. { protocol: "sagemaker", region: "eu-west-1" }. */
+    proxyModelConfiguration?: Record<string, unknown>;
+}
+/** Full saved-model settings document as returned by GET, sent back by PUT. */
+export type SavedModelSettings = Record<string, unknown>;
+/** Body of POST .../actions/delete-versions (official Python client, see docs note below). */
+export interface SavedModelDeleteVersionsRequest extends Record<string, unknown> {
+    versions: string[];
+    removeIntermediate: boolean;
+}
+/** Query options for MLflow version import (POST .../versions/{versionId}). */
+export interface SavedModelVersionImportOptions extends Record<string, unknown> {
+    codeEnvName?: string;
+    containerExecConfigName?: string;
+    setActive?: boolean;
+    binaryClassificationThreshold?: number;
+}
+/** Body of POST .../external-ml/actions/evaluate. */
+export interface ExternalModelVersionEvaluateRequest extends Record<string, unknown> {
+    datasetRef: string;
+    containerExecConfigName?: string;
+    samplingParam?: Record<string, unknown> | null;
+}
+/** Query flags for .../external-ml/actions/evaluate. */
+export interface ExternalModelVersionEvaluateOptions extends Record<string, unknown> {
+    useOptimalThreshold?: boolean;
+    skipExpensiveReports?: boolean;
+}
+/** Query options for the scoring JAR export (GET .../scoring-jar). */
+export interface SavedModelScoringJarOptions extends Record<string, unknown> {
+    fullClassName?: string;
+    includeLibs?: boolean;
+}
 export declare class SavedModelsResource extends BaseResource {
     /** List saved models in a project. */
     list(projectKey?: string): Promise<SavedModelListItem[]>;
-    /** Get saved-model settings and metadata. */
+    /**
+     * Create a saved model for storing and managing MLflow or external
+     * (proxy) models. POST /projects/{pkey}/savedmodels/ (the official Python
+     * client's collection-root creation endpoint; `/create-external` 405s).
+     */
+    createExternal(request: SavedModelCreateRequest, projectKey?: string): Promise<SavedModel>;
+    /**
+     * Get saved-model settings and metadata.
+     * GET /projects/{pkey}/savedmodels/{savedModelId}
+     */
     get(savedModelId: string, projectKey?: string): Promise<SavedModel>;
+    /**
+     * Save the full settings document of a saved model. The body must be the
+     * complete settings document as returned by {@link get} (GET-then-PUT
+     * workflow), per the official Python client's DSSSavedModelSettings.save().
+     */
+    updateSettings(savedModelId: string, settings: SavedModelSettings, projectKey?: string): Promise<void>;
     /** List all versions of a saved model. */
     listVersions(savedModelId: string, projectKey?: string): Promise<SavedModelVersionListItem[]>;
     /** Get full details for one saved-model version. */
     versionDetails(savedModelId: string, versionId: string, projectKey?: string): Promise<SavedModelVersionDetails>;
+    /** Get the short snippet (summary) for one saved-model version. */
+    versionSnippet(savedModelId: string, versionId: string, projectKey?: string): Promise<Record<string, unknown>>;
     /** Make one saved-model version active. */
     setActiveVersion(savedModelId: string, versionId: string, projectKey?: string): Promise<SavedModelActionResult | undefined>;
+    /**
+     * Delete one or more versions of a saved model.
+     *
+     * Transport note: the DSS 15 REST reference documents this action as GET
+     * `/projects/{pkey}/savedmodels/{savedModelId}/delete-versions{?versions}{?removeIntermediate}`,
+     * but the official Python client (dataikuapi/dss/savedmodel.py,
+     * DSSSavedModel.delete_versions, verified against dataiku-api-client-python
+     * master) performs `POST .../actions/delete-versions` with a JSON body
+     * `{versions, removeIntermediate}`. The REST doc is erroneous; this SDK
+     * follows the official client. The request is destructive and must never be
+     * retried automatically: retryMaxAttempts is pinned to 1 regardless of the
+     * client-level retry configuration.
+     */
+    deleteVersions(versions: string[], options?: {
+        removeIntermediate?: boolean;
+    }, savedModelId?: string, projectKey?: string): Promise<void>;
+    /**
+     * Import a new MLflow version from a local MLflow model archive
+     * (zip) uploaded as multipart/form-data.
+     * POST /projects/{pkey}/savedmodels/{savedModelId}/versions/{versionId}
+     * with query codeEnvName, containerExecConfigName, setActive,
+     * binaryClassificationThreshold.
+     */
+    importMlflowVersion(archivePath: string, versionId: string, options?: SavedModelVersionImportOptions, savedModelId?: string, projectKey?: string): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Import a new MLflow version from a path inside a managed folder. The
+     * server-side backend mandates a multipart request, so the part set is the
+     * same as the archive upload with a zero-byte "file" part, and the model
+     * location is carried by the folderRef (PROJECT_KEY.FOLDER_ID) and path
+     * query parameters — matching the official Python client, which sends
+     * `files={"file": (None, None)}`.
+     */
+    importMlflowVersionFromFolder(folderRef: string, folderPath: string, versionId: string, options?: SavedModelVersionImportOptions, savedModelId?: string, projectKey?: string): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Get the external-ml metadata of a saved-model version (MLflow or proxy
+     * model). Opaque server document; no strict schema is enforced.
+     */
+    externalMetadataGet(savedModelId: string, versionId: string, projectKey?: string): Promise<Record<string, unknown>>;
+    /**
+     * PUT the external-ml metadata of a saved-model version. The body must be
+     * the full metadata document as returned by {@link externalMetadataGet}
+     * (GET-then-PUT). DSS requires the containerExecConfigName query parameter
+     * on this endpoint (live: 400 "Required request parameter
+     * 'containerExecConfigName' not present" without it); for an external API
+     * caller the container exec config resolves as LOCAL-CONFIG -> NONE, so an
+     * omitted option sends NONE rather than dropping the parameter.
+     */
+    externalMetadataPut(savedModelId: string, versionId: string, metadata: Record<string, unknown>, options?: {
+        containerExecConfigName?: string;
+    }, projectKey?: string): Promise<void>;
+    /**
+     * Evaluate the performance of an external/MLflow model version on a
+     * dataset. POST .../external-ml/actions/evaluate with
+     * useOptimalThreshold/skipExpensiveReports as query parameters and the
+     * dataset/container/sampling payload in the JSON body.
+     */
+    evaluateVersion(request: ExternalModelVersionEvaluateRequest, options?: ExternalModelVersionEvaluateOptions, savedModelId?: string, versionId?: string, projectKey?: string): Promise<void>;
+    /**
+     * GET the scoring JAR of a version as a binary stream. Caller is
+     * responsible for consuming the response body (e.g. writeResponseToFile);
+     * the stream is read under the client body deadline.
+     */
+    downloadScoringJar(options: SavedModelScoringJarOptions | undefined, savedModelId: string, versionId: string, projectKey?: string): Promise<Response>;
+    /** GET the scoring PMML of a version as a binary/XML stream. */
+    downloadScoringPmml(savedModelId: string, versionId: string, projectKey?: string): Promise<Response>;
+    /**
+     * Update the user metadata of a model version. The body must only be the
+     * "userMeta" field of a previously-retrieved version-details object.
+     */
+    setUserMeta(savedModelId: string, versionId: string, userMeta: Record<string, unknown>, projectKey?: string): Promise<void>;
     /** Delete a saved model and all of its versions. */
     delete(savedModelId: string, projectKey?: string): Promise<void>;
+    private mlflowImportQuery;
     private savedModelPath;
 }