dataiku-sdk 3.2.0 → 3.4.0

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

package/dist/src/resources/saved-models.js

@@ -1,20 +1,60 @@
-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");
+import { basename, } from "node:path";
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, requireNonEmpty, } from "./base.js";
+function requireObject(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ClientValidationError(`${name} must be a JSON object.`, "validation_failed");
     }
     return value;
 }
+function requireNonEmptyArray(value, name) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new ClientValidationError(`${name} must be a non-empty array.`, "validation_failed");
+    }
+    return value;
+}
+function boolQuery(value) {
+    return value === undefined ? "true" : String(value);
+}
+function numberQuery(value, fallback) {
+    return String(value ?? fallback);
+}
 export class SavedModelsResource extends BaseResource {
     /** List saved models in a project. */
     async list(projectKey) {
         return this.client.get(`/public/api/projects/${this.enc(projectKey)}/savedmodels/`);
     }
-    /** 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).
+     */
+    async createExternal(request, projectKey) {
+        const body = requireObject(request, "request");
+        if (typeof body.name !== "string" || body.name.trim().length === 0) {
+            throw new ClientValidationError("request.name must be a non-empty string.", "validation_failed");
+        }
+        if (body.savedModelType !== "MLFLOW_PYFUNC" && body.savedModelType !== "PROXY_MODEL") {
+            throw new ClientValidationError('request.savedModelType must be "MLFLOW_PYFUNC" or "PROXY_MODEL".', "validation_failed");
+        }
+        return this.client.post(`/public/api/projects/${this.enc(projectKey)}/savedmodels/`, body);
+    }
+    /**
+     * Get saved-model settings and metadata.
+     * GET /projects/{pkey}/savedmodels/{savedModelId}
+     */
     async get(savedModelId, projectKey) {
         return this.client.get(this.savedModelPath(savedModelId, projectKey));
     }
+    /**
+     * 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().
+     */
+    async updateSettings(savedModelId, settings, projectKey) {
+        requireObject(settings, "settings");
+        await this.client.putVoid(this.savedModelPath(savedModelId, projectKey), settings);
+    }
     /** List all versions of a saved model. */
     async listVersions(savedModelId, projectKey) {
         return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions`);
@@ -24,15 +64,183 @@ export class SavedModelsResource extends BaseResource {
         const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
         return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/details`);
     }
+    /** Get the short snippet (summary) for one saved-model version. */
+    async versionSnippet(savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/snippet`);
+    }
     /** Make one saved-model version active. */
     async setActiveVersion(savedModelId, versionId, projectKey) {
         const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
         return this.client.post(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/actions/setActive`, {});
     }
+    /**
+     * 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.
+     */
+    async deleteVersions(versions, options, savedModelId, projectKey) {
+        const id = requireNonEmpty(savedModelId ?? "", "savedModelId");
+        const versionList = requireNonEmptyArray(versions, "versions");
+        const body = {
+            versions: versionList,
+            removeIntermediate: options?.removeIntermediate ?? true,
+        };
+        await this.client.post(`${this.savedModelPath(id, projectKey)}/actions/delete-versions`, body, 
+        // Mutating action: a retried attempt could double-delete after a lost
+        // response. One attempt only, explicitly overriding any future default.
+        { retryMaxAttempts: 1, });
+    }
+    /**
+     * 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.
+     */
+    async importMlflowVersion(archivePath, versionId, options, savedModelId, projectKey) {
+        const id = requireNonEmpty(savedModelId ?? "", "savedModelId");
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        const archive = requireNonEmpty(archivePath, "archivePath");
+        const exists = await Bun.file(archive).exists();
+        if (!exists) {
+            throw new ClientValidationError(`MLflow archive file not found: ${archive}.`, "validation_failed");
+        }
+        const query = this.mlflowImportQuery(options);
+        const parts = [
+            { name: "file", blob: Bun.file(archive), fileName: basename(archive), },
+        ];
+        return this.client.uploadForm(`${this.savedModelPath(id, projectKey)}/versions/${version}`, parts, query);
+    }
+    /**
+     * 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)}`.
+     */
+    async importMlflowVersionFromFolder(folderRef, folderPath, versionId, options, savedModelId, projectKey) {
+        const id = requireNonEmpty(savedModelId ?? "", "savedModelId");
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        const ref = requireNonEmpty(folderRef, "folderRef");
+        const path = requireNonEmpty(folderPath, "folderPath");
+        const query = this.mlflowImportQuery(options);
+        query.set("folderRef", ref);
+        query.set("path", path);
+        // Match the official client exactly: files={"file": (None, None)} — a
+        // filename-less, zero-length field part (a Blob part would carry a
+        // `filename=` parameter, which the endpoint rejects).
+        const parts = [{ name: "file", },];
+        return this.client.uploadForm(`${this.savedModelPath(id, projectKey)}/versions/${version}`, parts, query);
+    }
+    /**
+     * Get the external-ml metadata of a saved-model version (MLflow or proxy
+     * model). Opaque server document; no strict schema is enforced.
+     */
+    async externalMetadataGet(savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/external-ml/metadata`);
+    }
+    /**
+     * 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.
+     */
+    async externalMetadataPut(savedModelId, versionId, metadata, options, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        requireObject(metadata, "metadata");
+        const containerExecConfigName = options?.containerExecConfigName ?? "NONE";
+        const suffix = `?containerExecConfigName=${encodeURIComponent(containerExecConfigName)}`;
+        await this.client.putVoid(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/external-ml/metadata${suffix}`, metadata);
+    }
+    /**
+     * 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.
+     */
+    async evaluateVersion(request, options, savedModelId, versionId, projectKey) {
+        const id = requireNonEmpty(savedModelId ?? "", "savedModelId");
+        const version = encodeURIComponent(requireNonEmpty(versionId ?? "", "versionId"));
+        const requestBody = requireObject(request, "request");
+        if (typeof requestBody.datasetRef !== "string" || requestBody.datasetRef.trim().length === 0) {
+            throw new ClientValidationError("request.datasetRef must be a non-empty string.", "validation_failed");
+        }
+        // DSS 15 official external-caller semantics: the container exec config
+        // resolves as LOCAL-CONFIG -> NONE, so an omitted value sends NONE
+        // rather than being left out; an explicit value (including INHERIT)
+        // passes through unchanged. The caller's request object is never
+        // mutated — the default is applied to a copy.
+        const body = {
+            ...requestBody,
+            containerExecConfigName: requestBody.containerExecConfigName ?? "NONE",
+        };
+        const useOptimal = boolQuery(options?.useOptimalThreshold);
+        const skipExpensive = boolQuery(options?.skipExpensiveReports);
+        await this.client.post(`${this.savedModelPath(id, projectKey)}/versions/${version}/external-ml/actions/evaluate`
+            + `?useOptimalThreshold=${useOptimal}&skipExpensiveReports=${skipExpensive}`, body);
+    }
+    /**
+     * 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.
+     */
+    async downloadScoringJar(options, savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        const query = new URLSearchParams();
+        if (options?.fullClassName !== undefined) {
+            query.set("fullClassName", options.fullClassName);
+        }
+        if (options?.includeLibs !== undefined) {
+            query.set("includeLibs", String(options.includeLibs));
+        }
+        const suffix = [...query.keys(),].length > 0 ? `?${query.toString()}` : "";
+        return this.client.stream(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/scoring-jar${suffix}`);
+    }
+    /** GET the scoring PMML of a version as a binary/XML stream. */
+    async downloadScoringPmml(savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        return this.client.stream(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/scoring-pmml`);
+    }
+    /**
+     * Update the user metadata of a model version. The body must only be the
+     * "userMeta" field of a previously-retrieved version-details object.
+     */
+    async setUserMeta(savedModelId, versionId, userMeta, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        requireObject(userMeta, "userMeta");
+        await this.client.putVoid(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/user-meta`, userMeta);
+    }
     /** Delete a saved model and all of its versions. */
     async delete(savedModelId, projectKey) {
         await this.client.del(this.savedModelPath(savedModelId, projectKey));
     }
+    mlflowImportQuery(options) {
+        // DSS 15 official semantics: both import endpoints resolve the
+        // container exec config as LOCAL-CONFIG, i.e. NONE for an external
+        // caller, and DSS validates the parameter's presence (400 when
+        // omitted) — so an omitted option sends NONE. An explicit option
+        // (including INHERIT) passes through unchanged.
+        const query = new URLSearchParams();
+        query.set("codeEnvName", options?.codeEnvName ?? "INHERIT");
+        query.set("containerExecConfigName", options?.containerExecConfigName ?? "NONE");
+        query.set("setActive", boolQuery(options?.setActive));
+        query.set("binaryClassificationThreshold", numberQuery(options?.binaryClassificationThreshold, 0.5));
+        return query;
+    }
     savedModelPath(savedModelId, projectKey) {
         const id = encodeURIComponent(requireNonEmpty(savedModelId, "savedModelId"));
         return `/public/api/projects/${this.enc(projectKey)}/savedmodels/${id}`;

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

@@ -1,6 +1,55 @@
 import type { ScenarioDetails, ScenarioStatus, ScenarioSummary, ScenarioWaitResult } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export declare const SCENARIO_CANONICAL_EDITABLE_FIELDS: readonly ["params.steps", "params.triggers", "params.reporters", "params.customScript", "active", "name"];
+/** Default byte cap applied when fetching a scenario run log. */
+export declare const DEFAULT_SCENARIO_MAX_LOG_BYTES = 1048576;
+/** One entry of GET /scenarios/{id}/get-last-runs — a finished (or running) scenario run summary. */
+export interface ScenarioRunSummary {
+    runId: string;
+    start?: number;
+    end?: number;
+    scenario?: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+    result?: Record<string, unknown>;
+}
+/** Status payload returned by the scenario light endpoints: identity plus running/active flags. */
+export interface ScenarioLightStatus {
+    id?: string;
+    running?: boolean;
+    active?: boolean;
+}
+/** Result of a light active toggle: the light status observed after the PUT. */
+export interface ScenarioActiveUpdateResult {
+    scenarioId: string;
+    active: boolean;
+    before?: boolean;
+    status: ScenarioLightStatus;
+}
+/** Step-level entry of a scenario run report, sanitized to documented fields. */
+export interface ScenarioRunStepReport {
+    id?: string;
+    name?: string;
+    type?: string;
+    runId?: string;
+    start?: number;
+    end?: number;
+    outcome?: string;
+    warningCount?: number;
+}
+/** Response of GET /scenarios/{id}/get-run-for-trigger and GET /scenarios/{id}/{runId}. */
+export interface ScenarioRunDetails {
+    scenarioRun?: {
+        runId?: string;
+        result?: Record<string, unknown>;
+    };
+    stepRuns?: ScenarioRunStepReport[];
+}
+/** Bounded log retrieval result: text plus whether the byte cap cut it. */
+export interface ScenarioRunLog {
+    text: string;
+    truncated: boolean;
+    maxLogBytes: number;
+}
 export interface ScenarioUpdateNormalization {
     from: string;
     to: string;
@@ -118,6 +167,62 @@ export declare class ScenariosResource extends BaseResource {
         keepScenario?: boolean;
         maxLogBytes?: number;
     }): Promise<ScenarioScriptRunResult>;
+    /**
+     * Abort a running scenario (POST /scenarios/{id}/abort). The call returns as
+     * soon as DSS accepts the abort request; the scenario may take some time to
+     * actually stop, so this does not wait for termination.
+     */
+    abort(scenarioId: string, projectKey?: string): Promise<void>;
+    /** Get the raw last-runs list (GET /scenarios/{id}/get-last-runs/?limit=N). */
+    getLastRuns(scenarioId: string, opts?: {
+        limit?: number;
+        projectKey?: string;
+    }): Promise<ScenarioRunSummary[]>;
+    /** Get the details of a specific run (GET /scenarios/{id}/{runId}). */
+    getRunDetails(scenarioId: string, runId: string, opts?: {
+        projectKey?: string;
+    }): Promise<ScenarioRunDetails>;
+    /**
+     * Get the log of a scenario run (GET /scenarios/{id}/{runId}/log), optionally
+     * scoped to a single step via `stepId`. The text is byte-bounded: at most
+     * `maxLogBytes` (default 1 MiB) of the beginning of the log is retained and
+     * `truncated` reports whether the cap cut the body.
+     */
+    getRunLog(scenarioId: string, runId: string, opts?: {
+        stepId?: string;
+        maxLogBytes?: number;
+        projectKey?: string;
+    }): Promise<ScenarioRunLog>;
+    /** Get the payload of a (custom) scenario (GET /scenarios/{id}/payload). */
+    getPayload(scenarioId: string, opts?: {
+        projectKey?: string;
+    }): Promise<Record<string, unknown>>;
+    /** Update the payload of a (custom) scenario (PUT /scenarios/{id}/payload). */
+    setPayload(scenarioId: string, payload: Record<string, unknown>, opts?: {
+        projectKey?: string;
+    }): Promise<void>;
+    /**
+     * Toggle the active flag through the light endpoints (GET then PUT
+     * /scenarios/{id}/light) without a full-definition round-trip. Returns the
+     * light status observed after the PUT.
+     */
+    setActive(scenarioId: string, active: boolean, opts?: {
+        projectKey?: string;
+    }): Promise<ScenarioActiveUpdateResult>;
+    /**
+     * Poll get-run-for-trigger until the triggered run reports an outcome or the
+     * deadline elapses. Shared by runAndWait and runScript: POST /run/ returns a
+     * TRIGGER run id, which differs from the actual scenario run id, so the real
+     * run is resolved via get-run-for-trigger (the trigger id never matches
+     * lastRun and would misreport a completed scenario as a timeout).
+     */
+    private trackTriggerRun;
+    /**
+     * Best-effort step outcome summaries from the run report
+     * (GET /scenarios/{id}/{runId}). Never fails the wait: an unavailable
+     * run report returns undefined.
+     */
+    private runStepSummaries;
     /**
      * Delete the throwaway scenario at the end of a code run, or report the
      * explicit keep outcome. Never throws: delete failures are surfaced in the