dataiku-sdk 0.6.0 → 0.6.1

package/dist/src/index.d.ts

@@ -6,16 +6,16 @@ export { CodeEnvsResource, } from "./resources/code-envs.js";
 export { type ConnectionSchemaListOptions, ConnectionsResource, type ConnectionTableListOptions, } from "./resources/connections.js";
 export { DashboardsResource, } from "./resources/dashboards.js";
 export { DataQualityResource, } from "./resources/data-quality.js";
-export { type DatasetBuildValidationResult, type DatasetSchemaColumnInput, DatasetsResource, } from "./resources/datasets.js";
+export { type DatasetBuildValidationResult, type DatasetCloneOptions, type DatasetCloneResult, type DatasetSchemaColumnInput, DatasetsResource, } from "./resources/datasets.js";
 export { type FlowZoneItemInput, FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
 export { FuturesResource, } from "./resources/futures.js";
 export { InsightsResource, } from "./resources/insights.js";
-export { computeNextPollDelayMs, type JobBuildAndWaitOptions, type JobBuildOptions, type JobBuildTarget, type JobBuildTargetType, type JobLogFilter, type JobLogSummary, JobsResource, } from "./resources/jobs.js";
+export { computeNextPollDelayMs, type JobBuildAndWaitOptions, type JobBuildOptions, type JobBuildTarget, type JobBuildTargetType, type JobLogFilter, type JobLogProgress, type JobLogSummary, JobsResource, parseJobLogProgress, } from "./resources/jobs.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { type FlowMapResult, ProjectsResource, } from "./resources/projects.js";
-export { type RecipeGraphReference, type RecipeGraphValidationResult, type RecipeRunOptions, type RecipeRunOutput, type RecipeRunResult, RecipesResource, } from "./resources/recipes.js";
-export { ScenariosResource, } from "./resources/scenarios.js";
+export { type RecipeCloneOptions, type RecipeCloneResult, type RecipeGraphReference, type RecipeGraphValidationResult, type RecipeRunOptions, type RecipeRunOutput, type RecipeRunResult, RecipesResource, } from "./resources/recipes.js";
+export { normalizeScenarioUpdateData, SCENARIO_CANONICAL_EDITABLE_FIELDS, type ScenarioFieldChange, type ScenarioFieldMismatch, ScenariosResource, type ScenarioUpdateNormalization, type ScenarioUpdatePreview, scenarioUpdatePreview, type ScenarioUpdateResult, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { VariablesResource, } from "./resources/variables.js";
 export { WikiResource, } from "./resources/wiki.js";

package/dist/src/index.js

@@ -15,11 +15,11 @@ export { FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
 export { FuturesResource, } from "./resources/futures.js";
 export { InsightsResource, } from "./resources/insights.js";
-export { computeNextPollDelayMs, JobsResource, } from "./resources/jobs.js";
+export { computeNextPollDelayMs, JobsResource, parseJobLogProgress, } from "./resources/jobs.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { ProjectsResource, } from "./resources/projects.js";
 export { RecipesResource, } from "./resources/recipes.js";
-export { ScenariosResource, } from "./resources/scenarios.js";
+export { normalizeScenarioUpdateData, SCENARIO_CANONICAL_EDITABLE_FIELDS, ScenariosResource, scenarioUpdatePreview, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { VariablesResource, } from "./resources/variables.js";
 export { WikiResource, } from "./resources/wiki.js";

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

@@ -14,6 +14,21 @@ export interface DatasetSchemaColumnInput {
     type: string;
     comment?: string;
 }
+export interface DatasetCloneOptions {
+    projectKey?: string;
+    path?: string;
+    table?: string;
+    metastoreTableName?: string;
+    overrides?: Record<string, unknown>;
+    allowSamePath?: boolean;
+}
+export interface DatasetCloneResult {
+    source: string;
+    target: string;
+    projectKey: string;
+    created: Record<string, unknown>;
+    settings: Record<string, unknown>;
+}
 /**
  * Compare streamed TSV header columns against a known dataset schema.
  * Returns an array of warning strings (empty if all columns match).
@@ -21,6 +36,7 @@ export interface DatasetSchemaColumnInput {
 export declare function validateStreamColumns(headerRow: string[], expectedColumns: {
     name: string;
 }[]): string[];
+export declare function buildDatasetCloneSettings(source: DatasetDetails, targetName: string, projectKey: string, opts: DatasetCloneOptions): Record<string, unknown>;
 export declare class DatasetsResource extends BaseResource {
     /** List all datasets in a project. */
     list(projectKey?: string): Promise<DatasetSummary[]>;
@@ -69,6 +85,8 @@ export declare class DatasetsResource extends BaseResource {
     create(opts: DatasetCreateOptions): Promise<Record<string, unknown>>;
     /** Validate common build blockers before running a dataset build. */
     validateBuildSettings(datasetName: string, projectKey?: string): Promise<DatasetBuildValidationResult>;
+    /** Clone dataset settings, preserving connection/storage, format, and schema fields. */
+    clone(sourceName: string, targetName: string, opts?: DatasetCloneOptions): Promise<DatasetCloneResult>;
     /** Update a dataset by deep-merging a patch into the current definition. */
     update(datasetName: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
     /** Delete a dataset. */

package/dist/src/resources/datasets.js

@@ -306,6 +306,38 @@ function buildDatasetCreateBody(opts) {
         managed: opts.managed ?? true,
     };
 }
+export function buildDatasetCloneSettings(source, targetName, projectKey, opts) {
+    const params = {
+        ...source.params,
+        ...(opts.path !== undefined ? { path: opts.path, } : {}),
+        ...(opts.table !== undefined ? { table: opts.table, mode: "table", } : {}),
+        ...(opts.metastoreTableName !== undefined
+            ? { metastoreTableName: opts.metastoreTableName, }
+            : {}),
+    };
+    const cloned = {
+        name: targetName,
+        projectKey,
+        ...(source.type !== undefined ? { type: source.type, } : {}),
+        ...(source.managed !== undefined ? { managed: source.managed, } : {}),
+        ...(Object.keys(params).length > 0 ? { params, } : {}),
+        ...(source.formatType !== undefined ? { formatType: source.formatType, } : {}),
+        ...(source.formatParams !== undefined ? { formatParams: source.formatParams, } : {}),
+        ...(source.schema !== undefined ? { schema: source.schema, } : {}),
+    };
+    const settings = opts.overrides ? deepMerge(cloned, opts.overrides) : cloned;
+    const settingsParams = settings.params && typeof settings.params === "object" && !Array.isArray(settings.params)
+        ? settings.params
+        : {};
+    const sourcePath = typeof source.params?.path === "string" ? source.params.path : undefined;
+    if (opts.allowSamePath !== true
+        && source.managed === true
+        && sourcePath !== undefined
+        && settingsParams.path === sourcePath) {
+        throw new Error(`Refusing to clone managed dataset "${source.name}" with the same storage path. Pass a new path or allowSamePath: true.`);
+    }
+    return settings;
+}
 // ---------------------------------------------------------------------------
 // Resource
 // ---------------------------------------------------------------------------
@@ -485,6 +517,13 @@ export class DatasetsResource extends BaseResource {
             warnings,
         };
     }
+    /** Clone dataset settings, preserving connection/storage, format, and schema fields. */
+    async clone(sourceName, targetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const settings = buildDatasetCloneSettings(await this.get(sourceName, pk), targetName, pk, opts);
+        const created = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/datasets/`, settings);
+        return { source: sourceName, target: targetName, projectKey: pk, created, settings, };
+    }
     /** Update a dataset by deep-merging a patch into the current definition. */
     async update(datasetName, data, projectKey) {
         const dsEnc = encodeURIComponent(datasetName);

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

@@ -2,10 +2,17 @@ import type { BuildMode, JobSummary, JobWaitResult } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER";
 export type JobLogFilter = "stdout" | "stderr" | "user" | "errors";
+export interface JobLogProgress {
+    lastProgressLine?: string;
+    doneLine?: string;
+    counters: Record<string, number>;
+    rowsPerMinute?: number;
+}
 export interface JobLogSummary {
     state: string;
     lineCount: number;
     lines: string[];
+    progress?: JobLogProgress;
 }
 export interface JobBuildTarget {
     id: string;
@@ -27,6 +34,7 @@ export interface JobBuildAndWaitOptions extends JobBuildOptions {
     pollIntervalMs?: number;
     timeoutMs?: number;
     logFilter?: JobLogFilter;
+    logId?: string;
     summary?: boolean;
 }
 interface ComputeNextPollDelayMsOptions {
@@ -40,6 +48,7 @@ interface ComputeNextPollDelayMsOptions {
  * capped at MAX_POLL_INTERVAL_MS (or baseIntervalMs if it's larger).
  */
 export declare function computeNextPollDelayMs({ pollCount, baseIntervalMs, adaptiveEnabled, }: ComputeNextPollDelayMsOptions): number;
+export declare function parseJobLogProgress(log: string, elapsedMs?: number): JobLogProgress | undefined;
 export declare class JobsResource extends BaseResource {
     /** List jobs in a project. */
     list(projectKey?: string): Promise<JobSummary[]>;
@@ -52,9 +61,13 @@ export declare class JobsResource extends BaseResource {
      */
     log(jobId: string, opts?: {
         activity?: string;
+        logId?: string;
         maxLogLines?: number;
         projectKey?: string;
     }): Promise<string>;
+    logFromUrl(logUrl: string, opts?: {
+        maxLogLines?: number;
+    }): Promise<string>;
     /**
      * Start a build job for one or more dataset or managed-folder outputs.
      * Returns the new job's ID.
@@ -95,6 +108,7 @@ export declare class JobsResource extends BaseResource {
         activity?: string;
         includeLogs?: boolean;
         logFilter?: JobLogFilter;
+        logId?: string;
         maxLogLines?: number;
         pollIntervalMs?: number;
         summary?: boolean;

package/dist/src/resources/jobs.js

@@ -104,13 +104,58 @@ function limitJobLog(log, maxLines) {
     const tail = lines.slice(-Math.max(1, limit)).join("\n");
     return hasTrailingLineBreak ? `${tail}\n` : tail;
 }
-function summarizeJobLog(state, log, maxLines) {
+function parsedCounterValue(value) {
+    return Number(value.replace(/,/g, ""));
+}
+export function parseJobLogProgress(log, elapsedMs) {
+    const counters = {};
+    let lastProgressLine;
+    let doneLine;
+    for (const line of jobLogLines(log)) {
+        const normalized = line.trim();
+        if (!normalized)
+            continue;
+        const lower = normalized.toLowerCase();
+        let matched = false;
+        for (const match of normalized.matchAll(/\b(scanned|matched|joined|written|emitted)\s+([0-9][0-9,]*)/gi)) {
+            counters[match[1].toLowerCase()] = parsedCounterValue(match[2]);
+            matched = true;
+        }
+        const written = normalized.match(/\b([0-9][0-9,]*)\s+rows\s+successfully\s+written\b/i);
+        if (written) {
+            counters.written = parsedCounterValue(written[1]);
+            doneLine = normalized;
+            matched = true;
+        }
+        if (lower.includes("done!")) {
+            doneLine = normalized;
+            matched = true;
+        }
+        if (matched)
+            lastProgressLine = normalized;
+    }
+    if (lastProgressLine === undefined && doneLine === undefined)
+        return undefined;
+    const writtenRows = counters.written ?? counters.emitted;
+    const rowsPerMinute = writtenRows !== undefined && elapsedMs !== undefined && elapsedMs > 0
+        ? writtenRows / (elapsedMs / 60_000)
+        : undefined;
+    return {
+        ...(lastProgressLine ? { lastProgressLine, } : {}),
+        ...(doneLine ? { doneLine, } : {}),
+        counters,
+        ...(rowsPerMinute !== undefined ? { rowsPerMinute, } : {}),
+    };
+}
+function summarizeJobLog(state, log, maxLines, elapsedMs) {
     const lines = jobLogLines(log).map((line) => line.trim()).filter((line) => line.length > 0);
     const summaryLines = lines.slice(-Math.max(1, maxLines));
+    const progress = parseJobLogProgress(log, elapsedMs);
     return {
         state,
         lineCount: lines.length,
         lines: summaryLines,
+        ...(progress ? { progress, } : {}),
     };
 }
 export class JobsResource extends BaseResource {
@@ -133,9 +178,21 @@ export class JobsResource extends BaseResource {
     async log(jobId, opts) {
         const jobEnc = encodeURIComponent(jobId);
         const query = opts?.activity ? `?activity=${encodeURIComponent(opts.activity)}` : "";
-        const log = await this.client.getText(`/public/api/projects/${this.enc(opts?.projectKey)}/jobs/${jobEnc}/log/${query}`);
+        // DSS cat-activity-log URLs require a browser session; API-key callers must use the public log endpoint.
+        const path = `/public/api/projects/${this.enc(opts?.projectKey)}/jobs/${jobEnc}/log/${query}`;
+        const log = await this.client.getText(path);
         return limitJobLog(log, opts?.maxLogLines);
     }
+    async logFromUrl(logUrl, opts) {
+        const parsed = new URL(logUrl, "http://dss.local");
+        const projectKey = parsed.searchParams.get("projectKey") ?? undefined;
+        const jobId = parsed.searchParams.get("jobId") ?? undefined;
+        const activity = parsed.searchParams.get("activityId") ?? undefined;
+        if (!projectKey || !jobId || !activity) {
+            throw new Error("Log URL must include projectKey, jobId, and activityId query parameters.");
+        }
+        return this.log(jobId, { activity, projectKey, maxLogLines: opts?.maxLogLines, });
+    }
     /**
      * Start a build job for one or more dataset or managed-folder outputs.
      * Returns the new job's ID.
@@ -168,6 +225,7 @@ export class JobsResource extends BaseResource {
             activity: opts?.activity,
             includeLogs: opts?.includeLogs,
             logFilter: opts?.logFilter,
+            logId: opts?.logId,
             maxLogLines: opts?.maxLogLines,
             pollIntervalMs: opts?.pollIntervalMs,
             summary: opts?.summary,
@@ -218,13 +276,14 @@ export class JobsResource extends BaseResource {
                     const rawLog = await this.log(jobId, {
                         activity: opts.activity,
                         maxLogLines: opts.summary ? 0 : opts.maxLogLines,
+                        logId: opts.logId,
                         projectKey: opts.projectKey,
                     });
                     const filteredLog = filterJobLog(rawLog, opts.logFilter);
                     if (opts.includeLogs)
                         log = limitJobLog(filteredLog, opts.maxLogLines);
                     if (opts.summary) {
-                        logSummary = summarizeJobLog(state, filteredLog, opts.maxLogLines ?? 20);
+                        logSummary = summarizeJobLog(state, filteredLog, opts.maxLogLines ?? 20, elapsedMs);
                     }
                 }
                 return {

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

@@ -42,6 +42,28 @@ export type RecipeRunResult = {
 } & ({
     jobId: string;
 } | JobWaitResult);
+export interface RecipeCloneOptions {
+    projectKey?: string;
+    name: string;
+    outputDataset?: string;
+    outputRewrites?: Record<string, string>;
+    inputRewrites?: Record<string, string>;
+    payloadRewrites?: Record<string, string>;
+    payloadTextRewrites?: Record<string, string>;
+    copyOutputSettings?: boolean;
+    outputPath?: string;
+    metastoreTableName?: string;
+}
+export interface RecipeCloneResult {
+    sourceRecipeName: string;
+    recipeName: string;
+    projectKey: string;
+    outputRewrites: Record<string, string>;
+    inputRewrites: Record<string, string>;
+    payloadRewrites: Record<string, string>;
+    payloadTextRewrites: Record<string, string>;
+    copiedOutputDatasets: string[];
+}
 export declare class RecipesResource extends BaseResource {
     /** List all recipes in a project. */
     list(projectKey?: string): Promise<RecipeSummary[]>;
@@ -75,6 +97,10 @@ export declare class RecipesResource extends BaseResource {
      * The `recipe` sub-object is deep-merged to preserve nested fields.
      */
     update(recipeName: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /** Replace a full recipe API document. */
+    replace(recipeName: string, document: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /** Clone recipe graph/settings and optionally clone a dataset output. */
+    clone(sourceName: string, opts: RecipeCloneOptions): Promise<RecipeCloneResult>;
     /**
     * Download a recipe code payload to a local file.
 

package/dist/src/resources/recipes.js

@@ -86,6 +86,54 @@ function recipeInputItems(recipe) {
     }
     return result;
 }
+function rewriteRefs(value, rewrites) {
+    if (Object.keys(rewrites).length === 0)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => rewriteRefs(item, rewrites));
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    const next = {};
+    for (const [key, item,] of Object.entries(record)) {
+        if (key === "ref" && typeof item === "string" && rewrites[item]) {
+            next[key] = rewrites[item];
+        }
+        else {
+            next[key] = rewriteRefs(item, rewrites);
+        }
+    }
+    return next;
+}
+function escapedRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rewritePayload(payload, rewrites, payloadTextRewrites = {}) {
+    if (payload === undefined
+        || (Object.keys(rewrites).length === 0 && Object.keys(payloadTextRewrites).length === 0)) {
+        return payload;
+    }
+    let next = payload;
+    for (const [from, to,] of Object.entries(rewrites)) {
+        if (!from)
+            continue;
+        const escaped = escapedRegExp(from);
+        next = next.replace(new RegExp(`\\bdataiku\\.(Dataset|Folder)\\(\\s*(['"])${escaped}\\2\\s*\\)`, "g"), (_match, kind, quote) => `dataiku.${kind}(${quote}${to}${quote})`);
+    }
+    for (const [from, to,] of Object.entries(payloadTextRewrites)) {
+        if (from.length > 0)
+            next = next.split(from).join(to);
+    }
+    return next;
+}
+function cloneRecipeDefinition(recipe, targetName, projectKey, rewrites) {
+    const cloned = rewriteRefs(structuredClone(recipe), rewrites);
+    delete cloned.versionTag;
+    delete cloned.neverBuilt;
+    cloned.name = targetName;
+    cloned.projectKey = projectKey;
+    return cloned;
+}
 function inferRecipeCodeExtension(recipeType) {
     const normalized = typeof recipeType === "string" ? recipeType.trim().toLowerCase() : "";
     if (!normalized)
@@ -562,6 +610,72 @@ export class RecipesResource extends BaseResource {
         const merged = { ...current, ...data, recipe: mergedRecipe, };
         await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, merged);
     }
+    /** Replace a full recipe API document. */
+    async replace(recipeName, document, projectKey) {
+        const enc = this.enc(projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, document);
+    }
+    /** Clone recipe graph/settings and optionally clone a dataset output. */
+    async clone(sourceName, opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const source = await this.get(sourceName, { includePayload: true, projectKey: pk, });
+        const outputRewrites = {};
+        if (opts.outputRewrites)
+            Object.assign(outputRewrites, opts.outputRewrites);
+        if (opts.outputDataset !== undefined) {
+            const outputs = recipeOutputItems(source.recipe).filter((item) => item.type !== "MANAGED_FOLDER");
+            if (outputs.length !== 1 && Object.keys(outputRewrites).length === 0) {
+                throw new Error(`Recipe "${sourceName}" has ${outputs.length} dataset outputs; pass explicit outputRewrites instead of outputDataset.`);
+            }
+            if (outputs[0])
+                outputRewrites[outputs[0].ref] = opts.outputDataset;
+        }
+        const inputRewrites = {};
+        if (opts.inputRewrites)
+            Object.assign(inputRewrites, opts.inputRewrites);
+        const graphRewrites = { ...inputRewrites, ...outputRewrites, };
+        const payloadRewrites = { ...graphRewrites, };
+        if (opts.payloadRewrites)
+            Object.assign(payloadRewrites, opts.payloadRewrites);
+        if (opts.copyOutputSettings === true
+            && Object.keys(outputRewrites).length > 1
+            && (opts.outputPath !== undefined || opts.metastoreTableName !== undefined)) {
+            throw new Error("Cannot reuse --path or --metastore-table for multiple cloned output datasets; pass per-output settings in a separate step.");
+        }
+        const payloadTextRewrites = {};
+        if (opts.payloadTextRewrites)
+            Object.assign(payloadTextRewrites, opts.payloadTextRewrites);
+        const recipe = cloneRecipeDefinition(source.recipe, opts.name, pk, graphRewrites);
+        const payload = rewritePayload(source.payload, payloadRewrites, payloadTextRewrites);
+        const copiedOutputDatasets = [];
+        if (opts.copyOutputSettings) {
+            for (const [from, to,] of Object.entries(outputRewrites)) {
+                await this.client.datasets.clone(from, to, {
+                    projectKey: pk,
+                    path: opts.outputPath,
+                    metastoreTableName: opts.metastoreTableName,
+                });
+                copiedOutputDatasets.push(to);
+            }
+        }
+        const rnEnc = encodeURIComponent(opts.name);
+        await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/recipes/`, {
+            recipePrototype: recipe,
+            creationSettings: payload !== undefined ? { script: payload, } : {},
+        });
+        await this.client.put(`/public/api/projects/${encodeURIComponent(pk)}/recipes/${rnEnc}`, { recipe, ...(payload !== undefined ? { payload, } : {}), });
+        return {
+            sourceRecipeName: sourceName,
+            recipeName: opts.name,
+            projectKey: pk,
+            outputRewrites,
+            inputRewrites,
+            payloadRewrites,
+            payloadTextRewrites,
+            copiedOutputDatasets,
+        };
+    }
     /**
     * Download a recipe code payload to a local file.
 

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

@@ -1,5 +1,41 @@
 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"];
+export interface ScenarioUpdateNormalization {
+    from: string;
+    to: string;
+    action: "promoted" | "ignored";
+    message: string;
+}
+export interface ScenarioFieldChange {
+    path: string;
+    before: unknown;
+    after: unknown;
+}
+export interface ScenarioFieldMismatch {
+    path: string;
+    expected: unknown;
+    actual: unknown;
+}
+export interface ScenarioUpdatePreview {
+    canonicalEditableFields: typeof SCENARIO_CANONICAL_EDITABLE_FIELDS;
+    normalization: ScenarioUpdateNormalization[];
+    normalizedData: Record<string, unknown>;
+    current: Record<string, unknown>;
+    next: Record<string, unknown>;
+    changes: ScenarioFieldChange[];
+    unchangedPaths: string[];
+}
+export interface ScenarioUpdateResult extends ScenarioUpdatePreview {
+    after: Record<string, unknown>;
+    verified: true;
+    mismatches: [];
+}
+export declare function normalizeScenarioUpdateData(data: Record<string, unknown>): {
+    normalizedData: Record<string, unknown>;
+    normalization: ScenarioUpdateNormalization[];
+};
+export declare function scenarioUpdatePreview(current: Record<string, unknown>, data: Record<string, unknown>): ScenarioUpdatePreview;
 export declare class ScenariosResource extends BaseResource {
     /** List all scenarios in a project. */
     list(projectKey?: string): Promise<ScenarioSummary[]>;
@@ -19,8 +55,8 @@ export declare class ScenariosResource extends BaseResource {
     }>;
     /** Get the light/status view of a scenario. */
     status(scenarioId: string, projectKey?: string): Promise<ScenarioStatus>;
-    /** Merge-update a scenario's definition. */
-    update(scenarioId: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /** Merge-update a scenario's definition, then refetch and verify requested fields persisted. */
+    update(scenarioId: string, data: Record<string, unknown>, projectKey?: string): Promise<ScenarioUpdateResult>;
     /** Delete a scenario. */
     delete(scenarioId: string, projectKey?: string): Promise<void>;
     /**