dataiku-sdk 4.1.0 → 4.2.0

package/dist/src/resources/messaging-channels.js

@@ -0,0 +1,108 @@
+import { readFile, } from "node:fs/promises";
+import { basename, } from "node:path";
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, requireArrayResponse, requireNonEmpty, requireObject, } from "./base.js";
+/** The JSON `message` part of the send request, shaped like the official Python client's payload. */
+export function mailMessagePayload(message) {
+    return {
+        from: message.from ?? null,
+        to: message.to,
+        cc: message.cc ?? null,
+        bcc: message.bcc ?? null,
+        subject: message.subject,
+        body: message.body,
+        plainText: message.plainText ?? false,
+    };
+}
+/** Query string of the send request. */
+export function mailSendQuery(projectKey, sendAsSingleMessage) {
+    return new URLSearchParams({
+        projectKey,
+        sendAsSingleMessage: String(sendAsSingleMessage ?? false),
+    });
+}
+/** The POST body of a channel creation, as the official Python client sends it. */
+export function messagingChannelCreateBody(request) {
+    return {
+        id: request.id ? requireNonEmpty(request.id, "channelId") : "",
+        type: requireNonEmpty(request.type, "type"),
+        configuration: request.configuration === undefined
+            ? {}
+            : requireObject(request.configuration, "configuration"),
+        permissions: request.permissions ?? null,
+    };
+}
+export class MessagingChannelsResource extends BaseResource {
+    /** List messaging channels visible to the caller, optionally filtered by type or family. */
+    async list(options = {}) {
+        const query = new URLSearchParams();
+        if (options.channelType !== undefined)
+            query.set("channelType", options.channelType);
+        if (options.channelFamily !== undefined)
+            query.set("channelFamily", options.channelFamily);
+        const suffix = query.size > 0 ? `?${query.toString()}` : "";
+        const channels = await this.client.get(`/public/api/messaging-channels/${suffix}`);
+        return requireArrayResponse(channels, "messagingChannels.list");
+    }
+    /** Get one channel (type, family, and for mail channels the sender). */
+    async get(channelId) {
+        return this.client.get(this.channelPath(channelId));
+    }
+    /** Create a channel (admin). DSS returns the created channel. */
+    async create(request) {
+        return this.client.post("/public/api/messaging-channels/", messagingChannelCreateBody(request));
+    }
+    /** Get a channel's settings, i.e. its configuration (admin). */
+    async getSettings(channelId) {
+        return this.client.get(`${this.channelPath(channelId)}/settings`);
+    }
+    /** Replace a channel's settings (admin); pass the object obtained from {@link getSettings}. */
+    async saveSettings(channelId, settings) {
+        await this.client.putVoid(`${this.channelPath(channelId)}/settings`, requireObject(settings, "settings"));
+    }
+    /** Get the users and groups allowed to use a channel. */
+    async getPermissions(channelId) {
+        const permissions = await this.client.get(`${this.channelPath(channelId)}/permissions`);
+        return requireArrayResponse(permissions, "messagingChannels.getPermissions");
+    }
+    /** Replace a channel's permission list. */
+    async setPermissions(channelId, permissions) {
+        await this.client.putVoid(`${this.channelPath(channelId)}/permissions`, permissions);
+    }
+    /** Delete a channel (admin). */
+    async delete(channelId) {
+        await this.client.del(this.channelPath(channelId));
+    }
+    /**
+     * Send an email through a mail-family channel, as a multipart request: a JSON
+     * `message` part plus one `attachments` part per file. This sends real mail
+     * and is never retried.
+     */
+    async send(channelId, message, options = {}) {
+        const parts = [{
+                name: "message",
+                blob: new Blob([JSON.stringify(mailMessagePayload(message)),], {
+                    type: "application/json",
+                }),
+                fileName: "send-payload.json",
+            },];
+        for (const attachment of options.attachments ?? []) {
+            let blob;
+            try {
+                blob = new Blob([await readFile(attachment.path),]);
+            }
+            catch {
+                throw new ClientValidationError(`Attachment could not be read: ${attachment.path}`, "validation_failed", "Verify that the path names an existing, readable file.", { path: attachment.path, });
+            }
+            parts.push({
+                name: "attachments",
+                blob,
+                fileName: attachment.fileName ?? basename(attachment.path),
+            });
+        }
+        await this.client.uploadFormVoid(`${this.channelPath(channelId)}/actions/send`, parts, mailSendQuery(this.resolveProjectKey(options.projectKey), options.sendAsSingleMessage));
+    }
+    channelPath(channelId) {
+        return `/public/api/messaging-channels/${encodeURIComponent(requireNonEmpty(channelId, "channelId"))}`;
+    }
+}

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

@@ -87,6 +87,12 @@ export interface ProjectImportResult extends ProjectImportProcessResult {
     /** SHA-256 fingerprint of the landed project's creationTag. Present on verified success. */
     projectIncarnationHash?: string;
 }
+export interface TestScenarioRunsReportOptions {
+    /** Automation-node bundle whose test runs are reported; the active bundle when omitted. */
+    bundleId?: string;
+    /** `junit` (default) is JUnit XML; `html` is a rendered page. */
+    format?: "junit" | "html";
+}
 export declare class ProjectsResource extends BaseResource {
     /** Create a new project. */
     createProject(projectKey: string, name: string, ownerLogin: string, settings?: ProjectLifecycleSettings | null): Promise<Record<string, unknown>>;
@@ -139,6 +145,24 @@ export declare class ProjectsResource extends BaseResource {
      * covers branches, commits, pulls, and remotes.
      */
     pushToGitRemote(remote: string, projectKey?: string): Promise<void>;
+    /**
+     * Get the testing status of a project: the worst outcome across the last
+     * runs of its test scenarios. On an Automation node, `bundleId` restricts
+     * the runs to those made while that bundle was active.
+     */
+    getTestingStatus(projectKey?: string, bundleId?: string): Promise<Record<string, unknown>>;
+    /**
+     * Fetch the report of the latest test-scenario runs as text: JUnit XML by
+     * default, an HTML page for `format: "html"`. On an Automation node,
+     * `bundleId` selects the bundle; otherwise the active bundle is reported.
+     */
+    getTestScenarioRunsReport(projectKey?: string, options?: TestScenarioRunsReportOptions): Promise<string>;
+    /**
+     * Download the latest test-scenario runs report to a local file and return
+     * the byte count written. The file is only published once complete.
+     */
+    downloadTestScenarioRunsReport(filePath: string, projectKey?: string, options?: TestScenarioRunsReportOptions): Promise<number>;
+    private testScenarioRoute;
     /** Get project-level tags (tag name → {color?}). */
     tags(projectKey?: string): Promise<ProjectTags>;
     /**

package/dist/src/resources/projects.js

@@ -102,6 +102,11 @@ const DEFAULT_MAX_NODES = 300;
 const DEFAULT_MAX_EDGES = 600;
 const DEFAULT_METADATA_TIMEOUT_MS = 1_500;
 const PROJECT_IMPORT_AMBIGUOUS_REMEDIATION = "Import processing left DSS state indeterminate. Inspect the archive with `dss project inspect-archive <file>` and the live projects with `dss project list` before retrying the import.";
+function testReportRoute(options) {
+    return options.format === "html"
+        ? "last-test-scenario-runs-html-report"
+        : "last-test-scenario-runs-report";
+}
 export class ProjectsResource extends BaseResource {
     /** Create a new project. */
     async createProject(projectKey, name, ownerLogin, settings) {
@@ -319,6 +324,37 @@ export class ProjectsResource extends BaseResource {
     async pushToGitRemote(remote, projectKey) {
         await this.client.post(`/public/api/projects/${this.enc(projectKey)}/actions/push-to-git-remote?remote=${encodeURIComponent(remote)}`);
     }
+    /**
+     * Get the testing status of a project: the worst outcome across the last
+     * runs of its test scenarios. On an Automation node, `bundleId` restricts
+     * the runs to those made while that bundle was active.
+     */
+    async getTestingStatus(projectKey, bundleId) {
+        return this.client.get(this.testScenarioRoute(projectKey, "testing-status", bundleId));
+    }
+    /**
+     * Fetch the report of the latest test-scenario runs as text: JUnit XML by
+     * default, an HTML page for `format: "html"`. On an Automation node,
+     * `bundleId` selects the bundle; otherwise the active bundle is reported.
+     */
+    async getTestScenarioRunsReport(projectKey, options = {}) {
+        return this.client.getText(this.testScenarioRoute(projectKey, testReportRoute(options), options.bundleId));
+    }
+    /**
+     * Download the latest test-scenario runs report to a local file and return
+     * the byte count written. The file is only published once complete.
+     */
+    async downloadTestScenarioRunsReport(filePath, projectKey, options = {}) {
+        const res = await this.client.stream(this.testScenarioRoute(projectKey, testReportRoute(options), options.bundleId));
+        if (!res.body) {
+            throw unexpectedResponseError("projects.downloadTestScenarioRunsReport response did not include a body");
+        }
+        return writeResponseToFile(filePath, res);
+    }
+    testScenarioRoute(projectKey, route, bundleId) {
+        const query = bundleId === undefined ? "" : `?bundleId=${encodeURIComponent(bundleId)}`;
+        return `/public/api/projects/${this.enc(projectKey)}/scenarios/${route}${query}`;
+    }
     /** Get project-level tags (tag name → {color?}). */
     async tags(projectKey) {
         const enc = this.enc(projectKey);

package/dist/src/resources/scenario-authoring.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure builders for the JSON DSS stores under `triggers` and `reporters` of a
+ * scenario. Trigger shapes mirror dataikuapi's `add_periodic_trigger`,
+ * `add_hourly_trigger`, `add_daily_trigger` (which becomes a Weekly trigger when
+ * given days) and `add_monthly_trigger`; the mail reporter shape is the one DSS
+ * 15 stores for a `mail-scenario` reporter.
+ */
+export declare const SCENARIO_TRIGGER_FREQUENCIES: readonly ["minutely", "hourly", "daily", "weekly", "monthly"];
+export type ScenarioTriggerFrequency = typeof SCENARIO_TRIGGER_FREQUENCIES[number];
+export declare const SCENARIO_WEEKDAYS: readonly ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+export declare const SCENARIO_MONTHLY_RUN_ON: readonly ["ON_THE_DAY", "LAST_DAY_OF_THE_MONTH", "FIRST_WEEK", "SECOND_WEEK", "THIRD_WEEK", "FOURTH_WEEK", "LAST_WEEK"];
+export declare const SCENARIO_REPORTER_PHASES: readonly ["START", "END"];
+export interface TemporalTriggerSpec {
+    frequency: ScenarioTriggerFrequency;
+    /** Repeat interval: minutes (minutely), hours, days, weeks or months. */
+    every?: number;
+    /** Hour of the day (daily, weekly, monthly) or hour the schedule starts from (hourly). */
+    hour?: number;
+    minute?: number;
+    /** Weekday names; required by `weekly`, rejected elsewhere. */
+    days?: readonly string[];
+    /** Day of the month of the start date (monthly, default 1). */
+    dayOfMonth?: number;
+    runOn?: string;
+    /** `YYYY-MM-DD` day before which the trigger does not run; default today (monthly: January 1st of this year). */
+    startDate?: string;
+    timezone?: string;
+    name?: string;
+    active?: boolean;
+}
+/** The scenario trigger object dataikuapi would append for this schedule. */
+export declare function temporalTrigger(spec: TemporalTriggerSpec, now?: Date): Record<string, unknown>;
+export interface MailReporterSpec {
+    channel: string;
+    recipient: string;
+    subject: string;
+    message: string;
+    /** DSS expression gating the report, e.g. `outcome == 'FAILED'`. */
+    condition?: string;
+    phase?: string;
+    name?: string;
+    active?: boolean;
+}
+/** A `mail-scenario` reporter as DSS 15 stores it (inline message, Freemarker, no attachments). */
+export declare function mailReporter(spec: MailReporterSpec): Record<string, unknown>;
+/** Which element of a trigger/reporter list to remove. */
+export interface ScenarioListSelector {
+    index?: number;
+    name?: string;
+}
+/** Position of the selected element; ambiguous or missing selections throw. */
+export declare function selectScenarioListIndex(items: readonly unknown[], selector: ScenarioListSelector, kind: "trigger" | "reporter"): number;

package/dist/src/resources/scenario-authoring.js

@@ -0,0 +1,216 @@
+import { ClientValidationError, } from "../errors.js";
+import { isRecord, } from "../utils/records.js";
+/**
+ * Pure builders for the JSON DSS stores under `triggers` and `reporters` of a
+ * scenario. Trigger shapes mirror dataikuapi's `add_periodic_trigger`,
+ * `add_hourly_trigger`, `add_daily_trigger` (which becomes a Weekly trigger when
+ * given days) and `add_monthly_trigger`; the mail reporter shape is the one DSS
+ * 15 stores for a `mail-scenario` reporter.
+ */
+export const SCENARIO_TRIGGER_FREQUENCIES = [
+    "minutely",
+    "hourly",
+    "daily",
+    "weekly",
+    "monthly",
+];
+export const SCENARIO_WEEKDAYS = [
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    "Sunday",
+];
+export const SCENARIO_MONTHLY_RUN_ON = [
+    "ON_THE_DAY",
+    "LAST_DAY_OF_THE_MONTH",
+    "FIRST_WEEK",
+    "SECOND_WEEK",
+    "THIRD_WEEK",
+    "FOURTH_WEEK",
+    "LAST_WEEK",
+];
+export const SCENARIO_REPORTER_PHASES = ["START", "END",];
+function invalid(message) {
+    return new ClientValidationError(message, "invalid_flag_value");
+}
+/** Membership test that narrows a free-form string to one of the allowed literals. */
+function isOneOf(allowed, value) {
+    return allowed.includes(value);
+}
+function boundedInteger(value, name, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw invalid(`${name} must be an integer from ${min} to ${max}, got ${value}.`);
+    }
+    return value;
+}
+const pad = (value, width = 2) => String(value).padStart(width, "0");
+/**
+ * dataikuapi's `startingFrom`: local midnight of the date, with milliseconds and
+ * a `+HHMM` offset (taken from the machine's time zone, as dataikuapi does).
+ */
+function startingFrom(year, month, day) {
+    const local = new Date(year, month - 1, day, 0, 0, 0, 0);
+    if (local.getFullYear() !== year || local.getMonth() !== month - 1 || local.getDate() !== day) {
+        throw invalid(`${year}-${pad(month)}-${pad(day)} is not a calendar date.`);
+    }
+    const offsetMinutes = -local.getTimezoneOffset();
+    const sign = offsetMinutes < 0 ? "-" : "+";
+    const absolute = Math.abs(offsetMinutes);
+    return `${year}-${pad(month)}-${pad(day)}T00:00:00.000${sign}${pad(Math.floor(absolute / 60))}${pad(absolute % 60)}`;
+}
+function startingFromDate(startDate, fallback) {
+    if (startDate === undefined)
+        return fallback();
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(startDate);
+    if (!match)
+        throw invalid(`--start-date must be YYYY-MM-DD, got ${JSON.stringify(startDate)}.`);
+    return startingFrom(Number(match[1]), Number(match[2]), Number(match[3]));
+}
+/** The scenario trigger object dataikuapi would append for this schedule. */
+export function temporalTrigger(spec, now = new Date()) {
+    const every = spec.every === undefined
+        ? undefined
+        : boundedInteger(spec.every, "--every", 1, 100_000);
+    const timezone = spec.timezone ?? "SERVER";
+    if (spec.frequency !== "weekly" && spec.days !== undefined) {
+        throw invalid(`--days applies to weekly triggers only (got --frequency ${spec.frequency}).`);
+    }
+    if (spec.frequency !== "monthly" && (spec.runOn !== undefined || spec.dayOfMonth !== undefined)) {
+        throw invalid(`--run-on and --day-of-month apply to monthly triggers only (got --frequency ${spec.frequency}).`);
+    }
+    if (spec.frequency === "minutely") {
+        for (const [flag, value,] of [["--hour", spec.hour,], ["--minute", spec.minute,], [
+                "--start-date",
+                spec.startDate,
+            ], ["--timezone", spec.timezone,],]) {
+            if (value !== undefined)
+                throw invalid(`${flag} does not apply to minutely triggers.`);
+        }
+    }
+    const today = () => startingFrom(now.getFullYear(), now.getMonth() + 1, now.getDate());
+    const trigger = (params) => ({
+        ...(spec.name === undefined ? {} : { name: spec.name, }),
+        active: spec.active ?? true,
+        type: "temporal",
+        params,
+    });
+    if (spec.frequency === "minutely") {
+        return trigger({ frequency: "Minutely", repeatFrequency: every ?? 5, });
+    }
+    const minute = boundedInteger(spec.minute ?? 0, "--minute", 0, 59);
+    if (spec.frequency === "hourly") {
+        return trigger({
+            frequency: "Hourly",
+            hour: boundedInteger(spec.hour ?? 0, "--hour", 0, 23),
+            minute,
+            startingFrom: startingFromDate(spec.startDate, today),
+            repeatFrequency: every ?? 1,
+            timezone,
+        });
+    }
+    const hour = boundedInteger(spec.hour ?? 2, "--hour", 0, 23);
+    if (spec.frequency === "daily") {
+        return trigger({
+            frequency: "Daily",
+            hour,
+            minute,
+            startingFrom: startingFromDate(spec.startDate, today),
+            repeatFrequency: every ?? 1,
+            timezone,
+        });
+    }
+    if (spec.frequency === "weekly") {
+        if (spec.days === undefined || spec.days.length === 0) {
+            throw invalid(`--days is required for weekly triggers (${SCENARIO_WEEKDAYS.join(", ")}, comma-separated).`);
+        }
+        const unknown = spec.days.filter((day) => !isOneOf(SCENARIO_WEEKDAYS, day));
+        if (unknown.length > 0) {
+            throw invalid(`Unknown weekday ${unknown.map((day) => JSON.stringify(day)).join(", ")}; use ${SCENARIO_WEEKDAYS.join(", ")}.`);
+        }
+        return trigger({
+            frequency: "Weekly",
+            hour,
+            minute,
+            startingFrom: startingFromDate(spec.startDate, today),
+            daysOfWeek: [...spec.days,],
+            repeatFrequency: every ?? 1,
+            timezone,
+        });
+    }
+    const runOn = spec.runOn ?? "ON_THE_DAY";
+    if (!isOneOf(SCENARIO_MONTHLY_RUN_ON, runOn)) {
+        throw invalid(`--run-on must be one of ${SCENARIO_MONTHLY_RUN_ON.join(", ")}, got ${runOn}.`);
+    }
+    if (spec.startDate !== undefined && spec.dayOfMonth !== undefined) {
+        throw invalid("--start-date and --day-of-month are mutually exclusive for monthly triggers.");
+    }
+    const dayOfMonth = boundedInteger(spec.dayOfMonth ?? 1, "--day-of-month", 1, 31);
+    return trigger({
+        frequency: "Monthly",
+        startingFrom: startingFromDate(spec.startDate, 
+        // dataikuapi starts monthly schedules on January 1st (not today) so that day 31 never lands on a short month.
+        () => startingFrom(now.getFullYear(), 1, dayOfMonth)),
+        hour,
+        minute,
+        monthlyRunOn: runOn,
+        repeatFrequency: every ?? 1,
+        timezone,
+    });
+}
+function requiredText(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw invalid(`${name} must be a non-empty string.`);
+    }
+    return value;
+}
+/** A `mail-scenario` reporter as DSS 15 stores it (inline message, Freemarker, no attachments). */
+export function mailReporter(spec) {
+    const phase = spec.phase ?? "END";
+    if (!isOneOf(SCENARIO_REPORTER_PHASES, phase)) {
+        throw invalid(`--phase must be ${SCENARIO_REPORTER_PHASES.join(" or ")}, got ${phase}.`);
+    }
+    if (spec.condition !== undefined)
+        requiredText(spec.condition, "--condition");
+    return {
+        ...(spec.name === undefined ? {} : { name: spec.name, }),
+        active: spec.active ?? true,
+        phase,
+        runConditionEnabled: spec.condition !== undefined,
+        runCondition: spec.condition ?? "true",
+        messaging: {
+            type: "mail-scenario",
+            configuration: {
+                channelId: requiredText(spec.channel, "--channel"),
+                recipient: requiredText(spec.recipient, "--recipient"),
+                subject: spec.subject,
+                message: spec.message,
+                messageSource: "INLINE",
+                templateFormat: "FREEMARKER",
+                sendAsHTML: false,
+                attachments: [],
+            },
+        },
+    };
+}
+/** Position of the selected element; ambiguous or missing selections throw. */
+export function selectScenarioListIndex(items, selector, kind) {
+    if ((selector.index === undefined) === (selector.name === undefined)) {
+        throw invalid(`Pass exactly one of --index or --name to select the ${kind}.`);
+    }
+    if (selector.index !== undefined) {
+        if (!Number.isInteger(selector.index) || selector.index < 0 || selector.index >= items.length) {
+            throw invalid(`--index ${selector.index} is outside the ${items.length} ${kind}(s) of this scenario (0-based).`);
+        }
+        return selector.index;
+    }
+    const matches = items.flatMap((item, index) => isRecord(item) && item["name"] === selector.name ? [index,] : []);
+    if (matches.length !== 1) {
+        throw invalid(matches.length === 0
+            ? `No ${kind} is named ${JSON.stringify(selector.name)}.`
+            : `${matches.length} ${kind}s are named ${JSON.stringify(selector.name)} (indexes ${matches.join(", ")}); use --index.`);
+    }
+    return matches[0];
+}

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

@@ -1,6 +1,8 @@
 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"];
+import { type ScenarioListSelector } from "./scenario-authoring.js";
+/** DSS keeps triggers and reporters at the top level of the scenario (as dataikuapi does), not under params. */
+export declare const SCENARIO_CANONICAL_EDITABLE_FIELDS: readonly ["params.steps", "triggers", "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. */
@@ -44,6 +46,45 @@ export interface ScenarioRunDetails {
     };
     stepRuns?: ScenarioRunStepReport[];
 }
+/** One firing of a scenario trigger: what `POST /scenarios/{id}/run` returns (not a scenario run). */
+export interface ScenarioTriggerFire {
+    triggerId: string;
+    triggerRunId: string;
+    cancelled: boolean;
+}
+/** A trigger fire resolved against the scenario run it started (if any). */
+export interface ScenarioTriggerRunState extends ScenarioTriggerFire {
+    state: "PENDING" | "RUNNING" | "FINISHED" | "CANCELLED";
+    /** The scenario run id (what get-run and log take), once DSS started the run. */
+    runId?: string;
+    outcome?: string;
+    start?: number;
+}
+/** Test-scenario report text (JUnit XML), byte-bounded. */
+export interface ScenarioRunReport {
+    text: string;
+    truncated: boolean;
+    maxBytes: number;
+}
+export type ScenarioListKind = "trigger" | "reporter";
+/** Outcome of adding or removing one trigger/reporter. */
+export interface ScenarioListEdit {
+    kind: ScenarioListKind;
+    /** Position of the added element (as stored) or of the removed one. */
+    index: number;
+    /** The element as DSS stored it (added) or as it was (removed). */
+    item: unknown;
+    /** Elements left in the list. */
+    count: number;
+}
+export interface ScenarioRunAsResult {
+    scenarioId: string;
+    /** The explicit run-as login, or null when the scenario runs as its last editor. */
+    runAsUser: string | null;
+    /** Who the scenario actually runs as (dataikuapi `effective_run_as`). */
+    effectiveRunAs?: string;
+    previousRunAsUser?: string;
+}
 /** Bounded log retrieval result: text plus whether the byte cap cut it. */
 export interface ScenarioRunLog {
     text: string;
@@ -120,6 +161,8 @@ export interface ScenarioScriptRunResult {
     /** Observable throwaway-scenario cleanup outcome; never silently swallowed here. */
     cleanup: ScenarioScriptRunCleanup;
 }
+/** Who a scenario really runs as: its `runAsUser`, else the last editor (dataikuapi `effective_run_as`). */
+export declare function effectiveRunAs(scenario: Record<string, unknown>): string | undefined;
 export declare function normalizeScenarioUpdateData(data: Record<string, unknown>): {
     normalizedData: Record<string, unknown>;
     normalization: ScenarioUpdateNormalization[];
@@ -138,14 +181,23 @@ export declare class ScenariosResource extends BaseResource {
         data?: Record<string, unknown>;
         projectKey?: string;
     }): Promise<void>;
-    /** Trigger a scenario run. */
-    run(scenarioId: string, projectKey?: string): Promise<{
-        runId: string;
-    }>;
+    /**
+     * Trigger a scenario run. `params` is sent as the POST body (dataikuapi
+     * `run(params)`) and reaches the run as its trigger parameters. The result
+     * identifies the TRIGGER fire, not a scenario run: resolve it with
+     * {@link getRunForTrigger}. `cancelled` is already true when DSS refused the
+     * fire because the scenario is running.
+     */
+    run(scenarioId: string, opts?: {
+        params?: Record<string, unknown>;
+        projectKey?: string;
+    }): Promise<ScenarioTriggerFire>;
     /** Get the light/status view of a scenario. */
     status(scenarioId: string, projectKey?: string): Promise<ScenarioStatus>;
     /** Merge-update a scenario's definition, then refetch and verify requested fields persisted. */
     update(scenarioId: string, data: Record<string, unknown>, projectKey?: string): Promise<ScenarioUpdateResult>;
+    /** PUT the merge of `data` into an already-read scenario, refetch, and verify it persisted. */
+    private applyUpdate;
     /** Delete a scenario. */
     delete(scenarioId: string, projectKey?: string): Promise<void>;
     /**
@@ -153,6 +205,7 @@ export declare class ScenariosResource extends BaseResource {
      * Returns `{ success: false, timedOut: true }` on timeout rather than throwing.
      */
     runAndWait(scenarioId: string, opts?: {
+        params?: Record<string, unknown>;
         pollIntervalMs?: number;
         timeoutMs?: number;
         projectKey?: string;
@@ -177,11 +230,46 @@ export declare class ScenariosResource extends BaseResource {
      * 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). */
+    /**
+     * Get the raw last-runs list (GET /scenarios/{id}/get-last-runs/?limit=N).
+     * `onlyFinished` drops runs still in progress (DSS `onlyFinishedRuns`).
+     */
     getLastRuns(scenarioId: string, opts?: {
         limit?: number;
+        onlyFinished?: boolean;
         projectKey?: string;
     }): Promise<ScenarioRunSummary[]>;
+    /**
+     * Runs that started between two days (GET /scenarios/{id}/get-runs-by-date).
+     * Dates are `YYYY-MM-DD` or ISO date-times (the time part is dropped, as
+     * dataikuapi does). DSS treats `to` as exclusive (verified live: `from=to=today`
+     * is empty and today's runs need `to=tomorrow`), so it defaults to tomorrow
+     * rather than dataikuapi's today, which would leave today's runs out.
+     */
+    getRunsByDate(scenarioId: string, opts: {
+        from: string;
+        to?: string;
+        projectKey?: string;
+    }): Promise<ScenarioRunSummary[]>;
+    /**
+     * JUnit XML report of a test scenario run (GET /scenarios/{id}/{runId}/scenario-run-report),
+     * or of one step with `stepId` (…/step-run-report?stepId=). DSS only builds
+     * reports for scenarios marked as test; the text is byte-bounded like the log.
+     */
+    getRunReport(scenarioId: string, runId: string, opts?: {
+        stepId?: string;
+        maxBytes?: number;
+        projectKey?: string;
+    }): Promise<ScenarioRunReport>;
+    /**
+     * Resolve a trigger run (what `run` returns) to its scenario run: the scenario
+     * run id once DSS started one, or `CANCELLED` when DSS cancelled the fire (a
+     * run already in progress suppresses it) and no run will ever exist.
+     */
+    getRunForTrigger(scenarioId: string, triggerRunId: string, opts?: {
+        triggerId?: string;
+        projectKey?: string;
+    }): Promise<ScenarioTriggerRunState>;
     /** Get the details of a specific run (GET /scenarios/{id}/{runId}). */
     getRunDetails(scenarioId: string, runId: string, opts?: {
         projectKey?: string;
@@ -216,14 +304,43 @@ export declare class ScenariosResource extends BaseResource {
     setActive(scenarioId: string, active: boolean, opts?: {
         projectKey?: string;
     }): Promise<ScenarioActiveUpdateResult>;
+    /** The scenario's triggers or reporters, in DSS order (GET /scenarios/{id}/). */
+    listItems(kind: ScenarioListKind, scenarioId: string, opts?: {
+        projectKey?: string;
+    }): Promise<unknown[]>;
+    private getSettings;
+    /**
+     * Append a trigger or reporter. `triggers`/`reporters` are arrays, which a merge
+     * update replaces wholesale, so this reads the current list and writes it back
+     * with the new element last (then verifies the stored result).
+     */
+    addItem(kind: ScenarioListKind, scenarioId: string, item: Record<string, unknown>, opts?: {
+        projectKey?: string;
+    }): Promise<ScenarioListEdit>;
+    /** Remove the trigger or reporter selected by `--index`/`--name`, keeping every other element. */
+    removeItem(kind: ScenarioListKind, scenarioId: string, selector: ScenarioListSelector, opts?: {
+        projectKey?: string;
+    }): Promise<ScenarioListEdit>;
+    /**
+     * Set (`user`) or clear (`null`) the scenario's `runAsUser` (admin only for a
+     * non-null value). Clearing deletes the key, which a merge update cannot do.
+     */
+    setRunAs(scenarioId: string, user: string | null, opts?: {
+        projectKey?: string;
+    }): Promise<ScenarioRunAsResult>;
     /**
-     * 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).
+     * Poll get-run-for-trigger until the triggered run reports an outcome, DSS
+     * cancels the trigger fire, 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). While no scenario run exists yet, the trigger fire itself is read:
+     * DSS cancels a fire when the scenario is already running (or a newer fire
+     * replaces it), and then no run will ever appear.
      */
     private trackTriggerRun;
+    /** Whether DSS cancelled this trigger fire (GET /scenarios/trigger/{id}/{triggerId}?triggerRunId=). */
+    private isTriggerFireCancelled;
     /**
      * Best-effort step outcome summaries from the run report
      * (GET /scenarios/{id}/{runId}). Never fails the wait: an unavailable