@mobilerun/sdk 6.0.1 → 6.1.1

package/resources/workflows/flows/flows.d.ts

@@ -2,10 +2,13 @@ import { APIResource } from "../../../core/resource.js";
 import * as Shared from "../../shared.js";
 import * as ActionsAPI from "./actions.js";
 import { ActionAddParams, ActionAddResponse, ActionListResponse, ActionRemoveParams, ActionRemoveResponse, ActionReplaceParams, ActionReplaceResponse, Actions } from "./actions.js";
+import * as StateAPI from "./state.js";
+import { State, StateDeleteParams, StateDeleteResponse, StateListResponse, StateListVersionsParams, StateListVersionsResponse } from "./state.js";
 import { APIPromise } from "../../../core/api-promise.js";
 import { RequestOptions } from "../../../internal/request-options.js";
 export declare class Flows extends APIResource {
     actions: ActionsAPI.Actions;
+    state: StateAPI.State;
     /**
      * Create a flow that binds a trigger (`triggerId`) to an ordered list of actions,
      * with at least one action required. Optional settings include target `deviceIds`,
@@ -83,7 +86,8 @@ export declare class Flows extends APIResource {
      *   the trigger conditions.
      * - `custom`: validates the payload against the custom payload schema (conditions
      *   do not apply).
-     * - `schedule`: ignores the payload and reports the next fire time.
+     * - `schedule`: validates the stored trigger payload and its step references, and
+     *   reports the next fire time; request payload overrides are ignored.
      *
      * The response reports `wouldFire` — whether the flow would actually run right now
      * — alongside the gates that decide it (enabled, device attached, blocked,
@@ -94,6 +98,10 @@ export declare class Flows extends APIResource {
      * List self-healing repair episodes
      */
     listRepairs(flowID: string, options?: RequestOptions): APIPromise<FlowListRepairsResponse>;
+    /**
+     * Get a self-healing repair episode
+     */
+    retrieveRepair(episodeID: string, params: FlowRetrieveRepairParams, options?: RequestOptions): APIPromise<FlowRetrieveRepairResponse>;
     /**
      * Immediately enqueue one live execution on every device bound to the flow,
      * regardless of whether its trigger is event-based, custom, or scheduled.
@@ -137,7 +145,8 @@ export declare class Flows extends APIResource {
      * - `event`: validates the payload against the event catalog schema and evaluates
      *   the trigger conditions; a failing gate returns 409 `conditions_not_met` with
      *   the dry-run report.
-     * - `schedule`: the payload is ignored.
+     * - `schedule`: uses the stored trigger payload as event.payload; request payload
+     *   overrides are ignored.
      */
     verify(flowID: string, body: FlowVerifyParams, options?: RequestOptions): APIPromise<FlowVerifyResponse>;
 }
@@ -165,7 +174,12 @@ export declare namespace FlowCreateResponse {
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
-        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        /**
+         * Curated flow failure class. device_unavailable blocks immediately for a
+         * terminated device or a device confirmed gone; event deviceState="gone" is
+         * triggers-defined for a deleted/not-found device.
+         */
+        lastFailureCode: 'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
         lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
@@ -173,12 +187,18 @@ export declare namespace FlowCreateResponse {
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        ownerWake: 'final' | 'off';
         /**
          * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
          * recordingEnabled=true, "off" = recordingEnabled=false).
          */
         recordingEnabled: boolean;
         recordingPolicy: Data.RecordingPolicy;
+        /**
+         * Effective routine result delivery: the stored setting, else message for a chat
+         * sink, else none.
+         */
+        resultDelivery: 'none' | 'message' | 'wake';
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
@@ -201,7 +221,15 @@ export declare namespace FlowCreateResponse {
         interface Delivery {
             destination: 'mobilerun' | 'one_drive' | 'google_drive';
             /**
-             * not allowed when destination is mobilerun
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
              */
             folder?: string;
             recording?: Delivery.Recording;
@@ -239,9 +267,15 @@ export declare namespace FlowRetrieveResponse {
          * enabled.
          */
         enabled: boolean;
+        health: Data.Health;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
-        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        /**
+         * Curated flow failure class. device_unavailable blocks immediately for a
+         * terminated device or a device confirmed gone; event deviceState="gone" is
+         * triggers-defined for a deleted/not-found device.
+         */
+        lastFailureCode: 'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
         lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
@@ -249,12 +283,18 @@ export declare namespace FlowRetrieveResponse {
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        ownerWake: 'final' | 'off';
         /**
          * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
          * recordingEnabled=true, "off" = recordingEnabled=false).
          */
         recordingEnabled: boolean;
         recordingPolicy: Data.RecordingPolicy;
+        /**
+         * Effective routine result delivery: the stored setting, else message for a chat
+         * sink, else none.
+         */
+        resultDelivery: 'none' | 'message' | 'wake';
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
@@ -277,7 +317,15 @@ export declare namespace FlowRetrieveResponse {
         interface Delivery {
             destination: 'mobilerun' | 'one_drive' | 'google_drive';
             /**
-             * not allowed when destination is mobilerun
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
              */
             folder?: string;
             recording?: Delivery.Recording;
@@ -288,6 +336,33 @@ export declare namespace FlowRetrieveResponse {
                 filename: string;
             }
         }
+        interface Health {
+            /**
+             * Whether automatic health-status transitions are enabled; healthMonitoringEnabled
+             * must also be true.
+             */
+            autoBlockEnabled: boolean;
+            blockThreshold: number;
+            failingThreshold: number;
+            /**
+             * Default for new routines; this flow uses selfHealingMaxAttempts.
+             */
+            maxAttemptsDefault: number;
+            /**
+             * Permanent failure classes count toward the thresholds; invalid_config, preflight
+             * device_not_found, and device_unavailable with a terminated or confirmed gone
+             * device block immediately. Event deviceState="gone" is triggers-defined for a
+             * deleted/not-found device. Other device_unavailable states use normal thresholds;
+             * transient never counts.
+             */
+            permanentFailureCodes: Array<'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null>;
+            /**
+             * Configuration eligibility: health monitoring and self-healing are both enabled,
+             * and the flow is enabled and not deleted. Actual repair additionally requires an
+             * enabled repair worker and an eligible script execution/timeout failure.
+             */
+            selfHealingEligible: boolean;
+        }
         interface RecordingPolicy {
             mode: 'off' | 'flow' | 'selected_steps';
         }
@@ -317,7 +392,12 @@ export declare namespace FlowUpdateResponse {
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
-        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        /**
+         * Curated flow failure class. device_unavailable blocks immediately for a
+         * terminated device or a device confirmed gone; event deviceState="gone" is
+         * triggers-defined for a deleted/not-found device.
+         */
+        lastFailureCode: 'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
         lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
@@ -325,12 +405,18 @@ export declare namespace FlowUpdateResponse {
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        ownerWake: 'final' | 'off';
         /**
          * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
          * recordingEnabled=true, "off" = recordingEnabled=false).
          */
         recordingEnabled: boolean;
         recordingPolicy: Data.RecordingPolicy;
+        /**
+         * Effective routine result delivery: the stored setting, else message for a chat
+         * sink, else none.
+         */
+        resultDelivery: 'none' | 'message' | 'wake';
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
@@ -353,7 +439,15 @@ export declare namespace FlowUpdateResponse {
         interface Delivery {
             destination: 'mobilerun' | 'one_drive' | 'google_drive';
             /**
-             * not allowed when destination is mobilerun
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
              */
             folder?: string;
             recording?: Delivery.Recording;
@@ -394,7 +488,12 @@ export declare namespace FlowListResponse {
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
-        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        /**
+         * Curated flow failure class. device_unavailable blocks immediately for a
+         * terminated device or a device confirmed gone; event deviceState="gone" is
+         * triggers-defined for a deleted/not-found device.
+         */
+        lastFailureCode: 'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
         lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
@@ -402,12 +501,18 @@ export declare namespace FlowListResponse {
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        ownerWake: 'final' | 'off';
         /**
          * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
          * recordingEnabled=true, "off" = recordingEnabled=false).
          */
         recordingEnabled: boolean;
         recordingPolicy: Item.RecordingPolicy;
+        /**
+         * Effective routine result delivery: the stored setting, else message for a chat
+         * sink, else none.
+         */
+        resultDelivery: 'none' | 'message' | 'wake';
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
@@ -430,7 +535,15 @@ export declare namespace FlowListResponse {
         interface Delivery {
             destination: 'mobilerun' | 'one_drive' | 'google_drive';
             /**
-             * not allowed when destination is mobilerun
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
              */
             folder?: string;
             recording?: Delivery.Recording;
@@ -473,7 +586,12 @@ export declare namespace FlowActivateResponse {
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
-        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        /**
+         * Curated flow failure class. device_unavailable blocks immediately for a
+         * terminated device or a device confirmed gone; event deviceState="gone" is
+         * triggers-defined for a deleted/not-found device.
+         */
+        lastFailureCode: 'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
         lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
@@ -481,12 +599,18 @@ export declare namespace FlowActivateResponse {
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        ownerWake: 'final' | 'off';
         /**
          * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
          * recordingEnabled=true, "off" = recordingEnabled=false).
          */
         recordingEnabled: boolean;
         recordingPolicy: Data.RecordingPolicy;
+        /**
+         * Effective routine result delivery: the stored setting, else message for a chat
+         * sink, else none.
+         */
+        resultDelivery: 'none' | 'message' | 'wake';
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
@@ -509,7 +633,15 @@ export declare namespace FlowActivateResponse {
         interface Delivery {
             destination: 'mobilerun' | 'one_drive' | 'google_drive';
             /**
-             * not allowed when destination is mobilerun
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
              */
             folder?: string;
             recording?: Delivery.Recording;
@@ -559,7 +691,12 @@ export declare namespace FlowCloneResponse {
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
-        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        /**
+         * Curated flow failure class. device_unavailable blocks immediately for a
+         * terminated device or a device confirmed gone; event deviceState="gone" is
+         * triggers-defined for a deleted/not-found device.
+         */
+        lastFailureCode: 'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
         lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
@@ -567,12 +704,18 @@ export declare namespace FlowCloneResponse {
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        ownerWake: 'final' | 'off';
         /**
          * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
          * recordingEnabled=true, "off" = recordingEnabled=false).
          */
         recordingEnabled: boolean;
         recordingPolicy: Data.RecordingPolicy;
+        /**
+         * Effective routine result delivery: the stored setting, else message for a chat
+         * sink, else none.
+         */
+        resultDelivery: 'none' | 'message' | 'wake';
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
@@ -595,7 +738,15 @@ export declare namespace FlowCloneResponse {
         interface Delivery {
             destination: 'mobilerun' | 'one_drive' | 'google_drive';
             /**
-             * not allowed when destination is mobilerun
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
              */
             folder?: string;
             recording?: Delivery.Recording;
@@ -661,7 +812,7 @@ export declare namespace FlowDryRunResponse {
             method: string;
             name: string;
             recordingEnabled: boolean;
-            service: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks' | 'integrations_api';
+            service: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks' | 'integrations_api' | 'triggers_api';
             /**
              * Nested child actions (loop/branch bodies), each the same shape as a
              * ResolvedAction.
@@ -723,6 +874,40 @@ export declare namespace FlowListRepairsResponse {
         }
     }
 }
+export interface FlowRetrieveRepairResponse {
+    data: FlowRetrieveRepairResponse.Data;
+}
+export declare namespace FlowRetrieveRepairResponse {
+    interface Data {
+        id: string;
+        agentRunId: string | null;
+        attempt: number;
+        candidateSlug: string;
+        chatSessionId: string | null;
+        createdAt: string | null;
+        deviceId: string | null;
+        episode: number;
+        error: string | null;
+        failedStepIndex: number;
+        finishedAt: string | null;
+        flowId: string;
+        flowStatus: 'healthy' | 'failing' | 'blocked';
+        maxAttempts: number;
+        originalSlug: string;
+        sourceExecutionId: string;
+        startedAt: string | null;
+        status: 'pending' | 'running' | 'canary' | 'promoting' | 'repaired' | 'failed' | 'escalated';
+        updatedAt: string | null;
+        verdict: Data.Verdict | null;
+    }
+    namespace Data {
+        interface Verdict {
+            outcome: 'ok' | 'flaky' | 'broken';
+            summary: string;
+            reason?: string;
+        }
+    }
+}
 export interface FlowRunResponse {
     data: FlowRunResponse.Data;
 }
@@ -734,6 +919,30 @@ export declare namespace FlowRunResponse {
          * the original run.
          */
         executionIds: Array<string>;
+        /**
+         * At least one admitted execution failed queue submission. This is an enqueue
+         * error, not a skip. Keyed runs report prepared executions; post-commit submission
+         * failures are recorded on the execution instead.
+         */
+        enqueueFailed?: true;
+        /**
+         * Why no execution was admitted: device_required means no device and actions are
+         * not device-free eligible; flow_disabled means disabled at admission;
+         * flow_unavailable means missing or archived at admission. Blocked flows keep
+         * their existing error response. Manual runs bypass trigger conditions.
+         */
+        skipped?: Data.Skipped;
+    }
+    namespace Data {
+        /**
+         * Why no execution was admitted: device_required means no device and actions are
+         * not device-free eligible; flow_disabled means disabled at admission;
+         * flow_unavailable means missing or archived at admission. Blocked flows keep
+         * their existing error response. Manual runs bypass trigger conditions.
+         */
+        interface Skipped {
+            reason: 'device_required' | 'flow_disabled' | 'flow_unavailable';
+        }
     }
 }
 export interface FlowTemplateContextResponse {
@@ -757,7 +966,17 @@ export declare namespace FlowTemplateContextResponse {
         interface Root {
             description: string;
             name: string;
-            shape?: unknown;
+            /**
+             * Known root members; meta lists all execution calendar variables
+             */
+            shape: Array<Root.Shape> | null;
+        }
+        namespace Root {
+            interface Shape {
+                description: string;
+                example: string;
+                name: string;
+            }
         }
         interface StepReference {
             note: string;
@@ -791,7 +1010,12 @@ export declare namespace FlowUnblockResponse {
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
-        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        /**
+         * Curated flow failure class. device_unavailable blocks immediately for a
+         * terminated device or a device confirmed gone; event deviceState="gone" is
+         * triggers-defined for a deleted/not-found device.
+         */
+        lastFailureCode: 'device_not_found' | 'device_unavailable' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
         lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
@@ -799,12 +1023,18 @@ export declare namespace FlowUnblockResponse {
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        ownerWake: 'final' | 'off';
         /**
          * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
          * recordingEnabled=true, "off" = recordingEnabled=false).
          */
         recordingEnabled: boolean;
         recordingPolicy: Data.RecordingPolicy;
+        /**
+         * Effective routine result delivery: the stored setting, else message for a chat
+         * sink, else none.
+         */
+        resultDelivery: 'none' | 'message' | 'wake';
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
@@ -827,7 +1057,15 @@ export declare namespace FlowUnblockResponse {
         interface Delivery {
             destination: 'mobilerun' | 'one_drive' | 'google_drive';
             /**
-             * not allowed when destination is mobilerun
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
              */
             folder?: string;
             recording?: Delivery.Recording;
@@ -857,8 +1095,16 @@ export declare namespace FlowValidateResponse {
             code: string;
             field: string;
             message: string;
+            actionId?: string;
             knownSteps?: Array<string>;
             reference?: string;
+            repair?: Error.Repair;
+        }
+        namespace Error {
+            interface Repair {
+                action: 'fix_spec_and_restart' | 'ask_user' | 'retry_later';
+                hint: string;
+            }
         }
         interface Warning {
             code: string;
@@ -905,6 +1151,7 @@ export interface FlowCreateParams {
     notifyOnFailure?: boolean;
     notifyOnSuccess?: boolean;
     notifyWebhookId?: string | null;
+    ownerWake?: 'final' | 'off';
     recordingEnabled?: boolean;
     recordingPolicy?: FlowCreateParams.RecordingPolicy;
     selfHealingEnabled?: boolean;
@@ -961,7 +1208,15 @@ export declare namespace FlowCreateParams {
     interface Delivery {
         destination: 'mobilerun' | 'one_drive' | 'google_drive';
         /**
-         * not allowed when destination is mobilerun
+         * Absolute destination folder; not allowed when destination is mobilerun. May
+         * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+         * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+         * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+         * of that run lands in the same folder. Each substituted value must be a single
+         * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+         * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+         * delivered directly into the resolved folder; with a static folder they go into a
+         * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
          */
         folder?: string;
         recording?: Delivery.Recording;
@@ -992,6 +1247,7 @@ export interface FlowUpdateParams {
     notifyOnFailure?: boolean;
     notifyOnSuccess?: boolean;
     notifyWebhookId?: string | null;
+    ownerWake?: 'final' | 'off';
     /**
      * @deprecated Deprecated compatibility field. true maps to
      * recordingPolicy.mode="flow"; false maps to "off".
@@ -1006,7 +1262,15 @@ export declare namespace FlowUpdateParams {
     interface Delivery {
         destination: 'mobilerun' | 'one_drive' | 'google_drive';
         /**
-         * not allowed when destination is mobilerun
+         * Absolute destination folder; not allowed when destination is mobilerun. May
+         * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+         * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+         * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+         * of that run lands in the same folder. Each substituted value must be a single
+         * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+         * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+         * delivered directly into the resolved folder; with a static folder they go into a
+         * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
          */
         folder?: string;
         recording?: Delivery.Recording;
@@ -1063,6 +1327,9 @@ export interface FlowDryRunParams {
         [key: string]: unknown;
     };
 }
+export interface FlowRetrieveRepairParams {
+    flowId: string;
+}
 export interface FlowRunParams {
     /**
      * Record and keep this run's scripts.run screenshots
@@ -1077,47 +1344,33 @@ export interface FlowRunParams {
 export interface FlowTemplateContextParams {
     templateResolutionVersion?: number;
 }
-export interface FlowValidateParams {
-    actions: Array<FlowValidateParams.FlowActionInput | FlowValidateParams.FlowDraftActionInput>;
-    name: string;
-    cooldownScope?: 'flow' | 'device';
-    cooldownSeconds?: number | null;
-    delivery?: FlowValidateParams.Delivery;
-    description?: string;
-    deviceIds?: Array<string>;
-    enabled?: boolean;
-    healthMonitoringEnabled?: boolean;
-    notifyOnFailure?: boolean;
-    notifyOnSuccess?: boolean;
-    notifyWebhookId?: string | null;
-    recordingEnabled?: boolean;
-    recordingPolicy?: FlowValidateParams.RecordingPolicy;
-    selfHealingEnabled?: boolean;
-    selfHealingMaxAttempts?: number;
-    triggerId?: string;
-}
+export type FlowValidateParams = FlowValidateParams.Variant0 | FlowValidateParams.Variant1;
 export declare namespace FlowValidateParams {
-    interface FlowActionInput {
-        actionId: string;
-        position: number;
-        children?: Array<FlowActionInput.Child>;
-        continueOnError?: boolean;
-        /**
-         * Stable identifier used by template resolution v2+ to address this step as
-         * {{key.field}}. Omitted keys are derived from the step name whenever a flow is
-         * created. For template resolution v3, replacing an existing flow's full action
-         * tree requires every step to carry an explicit key — a missing key is rejected
-         * there, not derived, so a name change can never silently move a step's key.
-         */
-        key?: string;
-        nameOverride?: string;
-        overrides?: FlowActionInput.Overrides | null;
+    interface Variant0 {
+        actions: Array<Variant0.FlowActionInput | Variant0.FlowDraftActionInput>;
+        name: string;
+        cooldownScope?: 'flow' | 'device';
+        cooldownSeconds?: number | null;
+        delivery?: Variant0.Delivery;
+        description?: string;
+        deviceIds?: Array<string>;
+        enabled?: boolean;
+        healthMonitoringEnabled?: boolean;
+        notifyOnFailure?: boolean;
+        notifyOnSuccess?: boolean;
+        notifyWebhookId?: string | null;
+        ownerWake?: 'final' | 'off';
         recordingEnabled?: boolean;
+        recordingPolicy?: Variant0.RecordingPolicy;
+        selfHealingEnabled?: boolean;
+        selfHealingMaxAttempts?: number;
+        triggerId?: string;
     }
-    namespace FlowActionInput {
-        interface Child {
+    namespace Variant0 {
+        interface FlowActionInput {
             actionId: string;
             position: number;
+            children?: Array<FlowActionInput.Child>;
             continueOnError?: boolean;
             /**
              * Stable identifier used by template resolution v2+ to address this step as
@@ -1128,70 +1381,261 @@ export declare namespace FlowValidateParams {
              */
             key?: string;
             nameOverride?: string;
-            overrides?: Child.Overrides | null;
+            overrides?: FlowActionInput.Overrides | null;
             recordingEnabled?: boolean;
         }
-        namespace Child {
+        namespace FlowActionInput {
+            interface Child {
+                actionId: string;
+                position: number;
+                continueOnError?: boolean;
+                /**
+                 * Stable identifier used by template resolution v2+ to address this step as
+                 * {{key.field}}. Omitted keys are derived from the step name whenever a flow is
+                 * created. For template resolution v3, replacing an existing flow's full action
+                 * tree requires every step to carry an explicit key — a missing key is rejected
+                 * there, not derived, so a name change can never silently move a step's key.
+                 */
+                key?: string;
+                nameOverride?: string;
+                overrides?: Child.Overrides | null;
+                recordingEnabled?: boolean;
+            }
+            namespace Child {
+                interface Overrides {
+                    params?: {
+                        [key: string]: unknown;
+                    };
+                }
+            }
             interface Overrides {
                 params?: {
                     [key: string]: unknown;
                 };
             }
         }
-        interface Overrides {
-            params?: {
-                [key: string]: unknown;
-            };
+        interface FlowDraftActionInput {
+            draft: FlowDraftActionInput.Draft;
+            position: number;
+            continueOnError?: boolean;
+            /**
+             * Stable identifier used by template resolution v2+ to address this step as
+             * {{key.field}}. Omitted keys are derived from the step name whenever a flow is
+             * created. For template resolution v3, replacing an existing flow's full action
+             * tree requires every step to carry an explicit key — a missing key is rejected
+             * there, not derived, so a name change can never silently move a step's key.
+             */
+            key?: string;
+            nameOverride?: string;
+            overrides?: FlowDraftActionInput.Overrides | null;
+            recordingEnabled?: boolean;
+        }
+        namespace FlowDraftActionInput {
+            interface Draft {
+                method: string;
+                name: string;
+                service: string;
+                params?: {
+                    [key: string]: unknown;
+                };
+            }
+            interface Overrides {
+                params?: {
+                    [key: string]: unknown;
+                };
+            }
+        }
+        interface Delivery {
+            destination: 'mobilerun' | 'one_drive' | 'google_drive';
+            /**
+             * Absolute destination folder; not allowed when destination is mobilerun. May
+             * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+             * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+             * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+             * of that run lands in the same folder. Each substituted value must be a single
+             * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+             * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+             * delivered directly into the resolved folder; with a static folder they go into a
+             * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
+             */
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
         }
     }
-    interface FlowDraftActionInput {
-        draft: FlowDraftActionInput.Draft;
-        position: number;
-        continueOnError?: boolean;
-        /**
-         * Stable identifier used by template resolution v2+ to address this step as
-         * {{key.field}}. Omitted keys are derived from the step name whenever a flow is
-         * created. For template resolution v3, replacing an existing flow's full action
-         * tree requires every step to carry an explicit key — a missing key is rejected
-         * there, not derived, so a name change can never silently move a step's key.
-         */
-        key?: string;
-        nameOverride?: string;
-        overrides?: FlowDraftActionInput.Overrides | null;
-        recordingEnabled?: boolean;
+    interface Variant1 {
+        draft: Variant1.Draft;
+        agentId?: string;
+        contract?: Variant1.Contract;
+        verify?: Variant1.Verify;
     }
-    namespace FlowDraftActionInput {
+    namespace Variant1 {
         interface Draft {
-            method: string;
-            name: string;
-            service: string;
-            params?: {
+            actions: Array<Draft.Action>;
+            flow: Draft.Flow;
+            trigger: {
                 [key: string]: unknown;
             };
         }
-        interface Overrides {
-            params?: {
+        namespace Draft {
+            interface Action {
+                catalogEntryId: string;
+                name: string;
+                position: number;
+                role: string;
+                description?: string;
+                params?: {
+                    [key: string]: unknown;
+                };
+            }
+            interface Flow {
+                cooldownScope?: 'flow' | 'device';
+                cooldownSeconds?: number | null;
+                delivery?: Flow.Delivery;
+                description?: string;
+                deviceIds?: Array<string>;
+                executionMode?: 'device' | 'cloud';
+                healthMonitoringEnabled?: boolean;
+                name?: string;
+                recordingPolicy?: Flow.RecordingPolicy;
+                selfHealingEnabled?: boolean;
+                selfHealingMaxAttempts?: number;
+            }
+            namespace Flow {
+                interface Delivery {
+                    destination: 'mobilerun' | 'one_drive' | 'google_drive';
+                    /**
+                     * Absolute destination folder; not allowed when destination is mobilerun. May
+                     * contain {{meta.<name>}} (for example {{meta.shortDate}} = YYMMDD,
+                     * {{meta.fileTime}} = HH-mm, in the trigger timezone) and
+                     * {{event.payload.<field>}} placeholders, resolved once per run so every artifact
+                     * of that run lands in the same folder. Each substituted value must be a single
+                     * safe folder name (no "/", "\", "..", control characters); otherwise delivery
+                     * fails with invalid_delivery_folder. With a placeholder folder, screenshots are
+                     * delivered directly into the resolved folder; with a static folder they go into a
+                     * per-run "<flow>-<timestamp>-<id>-screenshots" subfolder.
+                     */
+                    folder?: string;
+                    recording?: Delivery.Recording;
+                    screenshots?: unknown;
+                }
+                namespace Delivery {
+                    interface Recording {
+                        filename: string;
+                    }
+                }
+                interface RecordingPolicy {
+                    mode: 'off' | 'flow' | 'selected_steps';
+                }
+            }
+        }
+        interface Contract {
+            /**
+             * Required without profile. Ignored with agent_routine; derived from
+             * meta.sink.type.
+             */
+            deliverable?: 'none' | 'file' | 'chat' | 'integration';
+            /**
+             * Ignored with agent_routine; derived from the action graph.
+             */
+            integrationRole?: string;
+            meta?: Contract.Meta;
+            /**
+             * Ignored with agent_routine; derived from the action graph.
+             */
+            producerRoles?: Array<string>;
+            profile?: 'agent_routine';
+            slug?: string;
+            /**
+             * Ignored with agent_routine; derived from the action graph.
+             */
+            uploadRole?: string;
+        }
+        namespace Contract {
+            interface Meta {
+                flow: Meta.Flow;
+                sink: Meta.Sink;
+                timezone: string | null;
+                trigger: Meta.Trigger;
+                verification: 'rules' | 'agent_review' | 'rules_then_review' | 'none';
+                cloudActions?: Array<Meta.CloudAction>;
+                outputFilename?: string | null;
+            }
+            namespace Meta {
+                interface Flow {
+                    healthMonitoringEnabled: boolean;
+                    selfHealingEnabled: boolean;
+                    selfHealingMaxAttempts: number;
+                    recordingMode?: 'off' | 'flow' | 'selected_steps';
+                    resultDelivery?: 'none' | 'message' | 'wake';
+                }
+                interface Sink {
+                    type: 'chat' | 'file' | 'webhook';
+                    endpointId?: string | null;
+                }
+                interface Trigger {
+                    /**
+                     * Accepted for compatibility; derived from trigger.type with agent_routine.
+                     */
+                    activation: 'event' | 'schedule' | 'custom';
+                    cadence: string | null;
+                    eventType: string | null;
+                    scheduleRule: Trigger.ScheduleRule;
+                    timezone: string | null;
+                    type: 'schedule' | 'app_event' | 'device_event' | 'platform_event' | 'custom';
+                }
+                namespace Trigger {
+                    interface ScheduleRule {
+                        type: 'once' | 'cron' | 'recurring';
+                        /**
+                         * ISO 8601 datetime (for type=once)
+                         */
+                        dateTime?: string;
+                        /**
+                         * Cron expression (for type=cron)
+                         */
+                        expression?: string;
+                        /**
+                         * Optional per-occurrence random window around the nominal schedule time
+                         */
+                        jitter?: ScheduleRule.Jitter;
+                        /**
+                         * RRULE string (for type=recurring)
+                         */
+                        rrule?: string;
+                        [k: string]: unknown;
+                    }
+                    namespace ScheduleRule {
+                        /**
+                         * Optional per-occurrence random window around the nominal schedule time
+                         */
+                        interface Jitter {
+                            afterMinutes?: number;
+                            beforeMinutes?: number;
+                        }
+                    }
+                }
+                interface CloudAction {
+                    method: string;
+                    role: string;
+                }
+            }
+        }
+        interface Verify {
+            deviceId?: string;
+            payload?: {
                 [key: string]: unknown;
             };
         }
     }
-    interface Delivery {
-        destination: 'mobilerun' | 'one_drive' | 'google_drive';
-        /**
-         * not allowed when destination is mobilerun
-         */
-        folder?: string;
-        recording?: Delivery.Recording;
-        screenshots?: unknown;
-    }
-    namespace Delivery {
-        interface Recording {
-            filename: string;
-        }
-    }
-    interface RecordingPolicy {
-        mode: 'off' | 'flow' | 'selected_steps';
-    }
 }
 export interface FlowVerifyParams {
     /**
@@ -1211,7 +1655,8 @@ export interface FlowVerifyParams {
     };
 }
 export declare namespace Flows {
-    export { type FlowCreateResponse as FlowCreateResponse, type FlowRetrieveResponse as FlowRetrieveResponse, type FlowUpdateResponse as FlowUpdateResponse, type FlowListResponse as FlowListResponse, type FlowDeleteResponse as FlowDeleteResponse, type FlowActivateResponse as FlowActivateResponse, type FlowCapacityResponse as FlowCapacityResponse, type FlowCloneResponse as FlowCloneResponse, type FlowDeliveryOptionsResponse as FlowDeliveryOptionsResponse, type FlowDryRunResponse as FlowDryRunResponse, type FlowListRepairsResponse as FlowListRepairsResponse, type FlowRunResponse as FlowRunResponse, type FlowTemplateContextResponse as FlowTemplateContextResponse, type FlowUnblockResponse as FlowUnblockResponse, type FlowValidateResponse as FlowValidateResponse, type FlowVerifyResponse as FlowVerifyResponse, type FlowCreateParams as FlowCreateParams, type FlowUpdateParams as FlowUpdateParams, type FlowListParams as FlowListParams, type FlowActivateParams as FlowActivateParams, type FlowCapacityParams as FlowCapacityParams, type FlowCloneParams as FlowCloneParams, type FlowDryRunParams as FlowDryRunParams, type FlowRunParams as FlowRunParams, type FlowTemplateContextParams as FlowTemplateContextParams, type FlowValidateParams as FlowValidateParams, type FlowVerifyParams as FlowVerifyParams, };
+    export { type FlowCreateResponse as FlowCreateResponse, type FlowRetrieveResponse as FlowRetrieveResponse, type FlowUpdateResponse as FlowUpdateResponse, type FlowListResponse as FlowListResponse, type FlowDeleteResponse as FlowDeleteResponse, type FlowActivateResponse as FlowActivateResponse, type FlowCapacityResponse as FlowCapacityResponse, type FlowCloneResponse as FlowCloneResponse, type FlowDeliveryOptionsResponse as FlowDeliveryOptionsResponse, type FlowDryRunResponse as FlowDryRunResponse, type FlowListRepairsResponse as FlowListRepairsResponse, type FlowRetrieveRepairResponse as FlowRetrieveRepairResponse, type FlowRunResponse as FlowRunResponse, type FlowTemplateContextResponse as FlowTemplateContextResponse, type FlowUnblockResponse as FlowUnblockResponse, type FlowValidateResponse as FlowValidateResponse, type FlowVerifyResponse as FlowVerifyResponse, type FlowCreateParams as FlowCreateParams, type FlowUpdateParams as FlowUpdateParams, type FlowListParams as FlowListParams, type FlowActivateParams as FlowActivateParams, type FlowCapacityParams as FlowCapacityParams, type FlowCloneParams as FlowCloneParams, type FlowDryRunParams as FlowDryRunParams, type FlowRetrieveRepairParams as FlowRetrieveRepairParams, type FlowRunParams as FlowRunParams, type FlowTemplateContextParams as FlowTemplateContextParams, type FlowValidateParams as FlowValidateParams, type FlowVerifyParams as FlowVerifyParams, };
     export { Actions as Actions, type ActionListResponse as ActionListResponse, type ActionAddResponse as ActionAddResponse, type ActionRemoveResponse as ActionRemoveResponse, type ActionReplaceResponse as ActionReplaceResponse, type ActionAddParams as ActionAddParams, type ActionRemoveParams as ActionRemoveParams, type ActionReplaceParams as ActionReplaceParams, };
+    export { State as State, type StateListResponse as StateListResponse, type StateDeleteResponse as StateDeleteResponse, type StateListVersionsResponse as StateListVersionsResponse, type StateDeleteParams as StateDeleteParams, type StateListVersionsParams as StateListVersionsParams, };
 }
 //# sourceMappingURL=flows.d.ts.map