@mobilerun/sdk 5.4.0 → 5.6.0

package/resources/workflows/flows/flows.d.mts

@@ -11,6 +11,10 @@ export declare class Flows extends APIResource {
      * with at least one action required. Optional settings include target `deviceIds`,
      * a cooldown (`cooldownSeconds`/`cooldownScope`), and webhook notifications on
      * success or failure.
+     *
+     * Supports an optional `Idempotency-Key` header (1-255 printable ASCII
+     * characters). Replays with the same key and an identical body return the original
+     * 201; a changed body under the same key returns 422 `idempotency_key_reused`.
      */
     create(body: FlowCreateParams, options?: RequestOptions): APIPromise<FlowCreateResponse>;
     /**
@@ -33,15 +37,41 @@ export declare class Flows extends APIResource {
      */
     list(query?: FlowListParams | null | undefined, options?: RequestOptions): APIPromise<FlowListResponse>;
     /**
-     * Delete a flow by its ID. Returns 404 if no flow matches.
+     * Terminally archive a flow by its ID. Archived flows cannot be restored and are
+     * hidden from customer reads. Repeating the request is idempotent for the owner.
      */
     delete(flowID: string, options?: RequestOptions): APIPromise<FlowDeleteResponse>;
+    /**
+     * Activate a disabled flow only when the supplied verification execution succeeded
+     * and the flow graph has not changed since verification. Repeating activation is
+     * idempotent for an already-enabled flow.
+     */
+    activate(flowID: string, body: FlowActivateParams, options?: RequestOptions): APIPromise<FlowActivateResponse>;
+    /**
+     * Returns an owner-scoped snapshot of finite included workflow-agent capacity
+     * after locally stored enabled and disabled agents. Available only while slot
+     * enforcement is enabled; otherwise returns 503. This is advisory; create and
+     * clone perform authoritative admission under an owner lock.
+     */
+    capacity(options?: RequestOptions): APIPromise<FlowCapacityResponse>;
     /**
      * Create a copy of an existing flow, including its actions and settings. The
      * optional body can override the new flow's `name` and target `deviceIds`. Returns
      * 404 if the source flow does not exist.
+     *
+     * Supports an optional `Idempotency-Key` header (1-255 printable ASCII
+     * characters). Replays with the same key and an identical body return the original
+     * 201; a changed body under the same key returns 422 `idempotency_key_reused`.
      */
     clone(flowID: string, body?: FlowCloneParams | null | undefined, options?: RequestOptions): APIPromise<FlowCloneResponse>;
+    /**
+     * Return the recording/delivery readiness for a flow (recording mode, whether
+     * delivery can include the recording, whether a files.upload action exists, the
+     * first direct OneDrive/Google Drive upload step if any) plus, per destination,
+     * whether the flow owner has an active integrations-api connection. Returns 404 if
+     * the flow does not exist.
+     */
+    deliveryOptions(flowID: string, options?: RequestOptions): APIPromise<FlowDeliveryOptionsResponse>;
     /**
      * Simulate this flow firing without storing events, enqueuing jobs, or consuming
      * cooldown/rate-limit slots.
@@ -63,11 +93,52 @@ export declare class Flows extends APIResource {
      * List self-healing repair episodes
      */
     listRepairs(flowID: string, options?: RequestOptions): APIPromise<FlowListRepairsResponse>;
+    /**
+     * Immediately enqueue one live execution on every device bound to the flow,
+     * regardless of whether its trigger is event-based, custom, or scheduled.
+     *
+     * Supports an optional `Idempotency-Key` header (1-255 printable ASCII
+     * characters). The run identity is derived from the key, so a retry never starts a
+     * second run. Replays with the same key and an identical body return the original
+     * status and the original `executionIds`; a changed body under the same key
+     * returns 422 `idempotency_key_reused`.
+     */
+    run(flowID: string, body?: FlowRunParams | null | undefined, options?: RequestOptions): APIPromise<FlowRunResponse>;
+    /**
+     * Get flow template context
+     */
+    templateContext(query?: FlowTemplateContextParams | null | undefined, options?: RequestOptions): APIPromise<FlowTemplateContextResponse>;
     /**
      * Clear a flow's blocked status after fixing the underlying issue. Idempotent —
      * safe to call on already-healthy flows.
      */
     unblock(flowID: string, options?: RequestOptions): APIPromise<FlowUnblockResponse>;
+    /**
+     * Validate a flow
+     */
+    validate(body: FlowValidateParams, options?: RequestOptions): APIPromise<FlowValidateResponse>;
+    /**
+     * Run a bound, deduplicated **verification** of this flow on exactly one device
+     * through the real worker.
+     *
+     * Unlike a normal trigger firing, verification:
+     *
+     * - runs a flow that is `enabled` OR `disabled` (an archived flow returns 404);
+     * - targets one device (`deviceId`, or the single bound device);
+     * - is idempotent per `invocationId`: a repeat returns the existing run
+     *   (`deduplicated: true`, HTTP 200) instead of enqueuing another (HTTP 202);
+     * - never mutates flow health, `lastTriggeredAt`, or the repair loop.
+     *
+     * Per-activation payload gate:
+     *
+     * - `custom`: validates the payload against the custom payload schema (422 on
+     *   failure).
+     * - `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.
+     */
+    verify(flowID: string, body: FlowVerifyParams, options?: RequestOptions): APIPromise<FlowVerifyResponse>;
 }
 export interface FlowCreateResponse {
     data: FlowCreateResponse.Data;
@@ -75,33 +146,46 @@ export interface FlowCreateResponse {
 export declare namespace FlowCreateResponse {
     interface Data {
         id: string;
+        archivedAt: string | null;
         blockedAt: string | null;
         consecutiveFailures: number;
         cooldownScope: 'flow' | 'device';
         cooldownSeconds: number | null;
         createdAt: string | null;
         createdBy: string | null;
+        delivery: Data.Delivery | null;
         description: string | null;
         deviceIds: Array<string>;
+        /**
+         * Compatibility projection of lifecycleStatus; true only when lifecycleStatus is
+         * enabled.
+         */
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
         lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
+        lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
         notifyOnFailure: boolean;
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        /**
+         * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
+         * recordingEnabled=true, "off" = recordingEnabled=false).
+         */
         recordingEnabled: boolean;
+        recordingPolicy: Data.RecordingPolicy;
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
         /**
          * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
          * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
-         * a whole-token null stays JSON null). Existing flows stay 1; new flows default
-         * to 2.
+         * a whole-token null stays JSON null). 3 = typed, key-based (steps are addressed
+         * as {{steps.<key>...}} instead of by name; trigger.payload is not available).
+         * Existing flows stay 1; new flows default to the current version.
          */
         templateResolutionVersion: number;
         triggerId: string;
@@ -111,6 +195,22 @@ export declare namespace FlowCreateResponse {
          */
         userId: string;
     }
+    namespace Data {
+        interface Delivery {
+            destination: 'one_drive' | 'google_drive';
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
+        }
+    }
 }
 export interface FlowRetrieveResponse {
     data: FlowRetrieveResponse.Data;
@@ -118,33 +218,46 @@ export interface FlowRetrieveResponse {
 export declare namespace FlowRetrieveResponse {
     interface Data {
         id: string;
+        archivedAt: string | null;
         blockedAt: string | null;
         consecutiveFailures: number;
         cooldownScope: 'flow' | 'device';
         cooldownSeconds: number | null;
         createdAt: string | null;
         createdBy: string | null;
+        delivery: Data.Delivery | null;
         description: string | null;
         deviceIds: Array<string>;
+        /**
+         * Compatibility projection of lifecycleStatus; true only when lifecycleStatus is
+         * enabled.
+         */
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
         lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
+        lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
         notifyOnFailure: boolean;
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        /**
+         * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
+         * recordingEnabled=true, "off" = recordingEnabled=false).
+         */
         recordingEnabled: boolean;
+        recordingPolicy: Data.RecordingPolicy;
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
         /**
          * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
          * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
-         * a whole-token null stays JSON null). Existing flows stay 1; new flows default
-         * to 2.
+         * a whole-token null stays JSON null). 3 = typed, key-based (steps are addressed
+         * as {{steps.<key>...}} instead of by name; trigger.payload is not available).
+         * Existing flows stay 1; new flows default to the current version.
          */
         templateResolutionVersion: number;
         triggerId: string;
@@ -154,6 +267,22 @@ export declare namespace FlowRetrieveResponse {
          */
         userId: string;
     }
+    namespace Data {
+        interface Delivery {
+            destination: 'one_drive' | 'google_drive';
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
+        }
+    }
 }
 export interface FlowUpdateResponse {
     data: FlowUpdateResponse.Data;
@@ -161,33 +290,46 @@ export interface FlowUpdateResponse {
 export declare namespace FlowUpdateResponse {
     interface Data {
         id: string;
+        archivedAt: string | null;
         blockedAt: string | null;
         consecutiveFailures: number;
         cooldownScope: 'flow' | 'device';
         cooldownSeconds: number | null;
         createdAt: string | null;
         createdBy: string | null;
+        delivery: Data.Delivery | null;
         description: string | null;
         deviceIds: Array<string>;
+        /**
+         * Compatibility projection of lifecycleStatus; true only when lifecycleStatus is
+         * enabled.
+         */
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
         lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
+        lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
         notifyOnFailure: boolean;
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        /**
+         * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
+         * recordingEnabled=true, "off" = recordingEnabled=false).
+         */
         recordingEnabled: boolean;
+        recordingPolicy: Data.RecordingPolicy;
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
         /**
          * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
          * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
-         * a whole-token null stays JSON null). Existing flows stay 1; new flows default
-         * to 2.
+         * a whole-token null stays JSON null). 3 = typed, key-based (steps are addressed
+         * as {{steps.<key>...}} instead of by name; trigger.payload is not available).
+         * Existing flows stay 1; new flows default to the current version.
          */
         templateResolutionVersion: number;
         triggerId: string;
@@ -197,6 +339,22 @@ export declare namespace FlowUpdateResponse {
          */
         userId: string;
     }
+    namespace Data {
+        interface Delivery {
+            destination: 'one_drive' | 'google_drive';
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
+        }
+    }
 }
 export interface FlowListResponse {
     items: Array<FlowListResponse.Item>;
@@ -205,33 +363,46 @@ export interface FlowListResponse {
 export declare namespace FlowListResponse {
     interface Item {
         id: string;
+        archivedAt: string | null;
         blockedAt: string | null;
         consecutiveFailures: number;
         cooldownScope: 'flow' | 'device';
         cooldownSeconds: number | null;
         createdAt: string | null;
         createdBy: string | null;
+        delivery: Item.Delivery | null;
         description: string | null;
         deviceIds: Array<string>;
+        /**
+         * Compatibility projection of lifecycleStatus; true only when lifecycleStatus is
+         * enabled.
+         */
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
         lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
+        lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
         notifyOnFailure: boolean;
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        /**
+         * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
+         * recordingEnabled=true, "off" = recordingEnabled=false).
+         */
         recordingEnabled: boolean;
+        recordingPolicy: Item.RecordingPolicy;
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
         /**
          * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
          * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
-         * a whole-token null stays JSON null). Existing flows stay 1; new flows default
-         * to 2.
+         * a whole-token null stays JSON null). 3 = typed, key-based (steps are addressed
+         * as {{steps.<key>...}} instead of by name; trigger.payload is not available).
+         * Existing flows stay 1; new flows default to the current version.
          */
         templateResolutionVersion: number;
         triggerId: string;
@@ -241,43 +412,154 @@ export declare namespace FlowListResponse {
          */
         userId: string;
     }
+    namespace Item {
+        interface Delivery {
+            destination: 'one_drive' | 'google_drive';
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
+        }
+    }
 }
 export interface FlowDeleteResponse {
     message: string;
 }
+export interface FlowActivateResponse {
+    data: FlowActivateResponse.Data;
+}
+export declare namespace FlowActivateResponse {
+    interface Data {
+        id: string;
+        archivedAt: string | null;
+        blockedAt: string | null;
+        consecutiveFailures: number;
+        cooldownScope: 'flow' | 'device';
+        cooldownSeconds: number | null;
+        createdAt: string | null;
+        createdBy: string | null;
+        delivery: Data.Delivery | null;
+        description: string | null;
+        deviceIds: Array<string>;
+        /**
+         * Compatibility projection of lifecycleStatus; true only when lifecycleStatus is
+         * enabled.
+         */
+        enabled: boolean;
+        healthMonitoringEnabled: boolean;
+        lastFailureAt: string | null;
+        lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
+        lastTriggeredAt: string | null;
+        lifecycleStatus: 'enabled' | 'disabled' | 'archived';
+        name: string;
+        notifyOnFailure: boolean;
+        notifyOnSuccess: boolean;
+        notifyWebhookId: string | null;
+        ownerId: string;
+        /**
+         * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
+         * recordingEnabled=true, "off" = recordingEnabled=false).
+         */
+        recordingEnabled: boolean;
+        recordingPolicy: Data.RecordingPolicy;
+        selfHealingEnabled: boolean;
+        selfHealingMaxAttempts: number;
+        status: 'healthy' | 'failing' | 'blocked';
+        /**
+         * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
+         * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
+         * a whole-token null stays JSON null). 3 = typed, key-based (steps are addressed
+         * as {{steps.<key>...}} instead of by name; trigger.payload is not available).
+         * Existing flows stay 1; new flows default to the current version.
+         */
+        templateResolutionVersion: number;
+        triggerId: string;
+        updatedAt: string | null;
+        /**
+         * @deprecated Deprecated: use ownerId (tenancy) / createdBy (actor).
+         */
+        userId: string;
+    }
+    namespace Data {
+        interface Delivery {
+            destination: 'one_drive' | 'google_drive';
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
+        }
+    }
+}
+export interface FlowCapacityResponse {
+    data: FlowCapacityResponse.Data;
+}
+export declare namespace FlowCapacityResponse {
+    interface Data {
+        included: number;
+        remaining: number;
+        status: 'available' | 'exhausted' | 'not_included';
+    }
+}
 export interface FlowCloneResponse {
     data: FlowCloneResponse.Data;
 }
 export declare namespace FlowCloneResponse {
     interface Data {
         id: string;
+        archivedAt: string | null;
         blockedAt: string | null;
         consecutiveFailures: number;
         cooldownScope: 'flow' | 'device';
         cooldownSeconds: number | null;
         createdAt: string | null;
         createdBy: string | null;
+        delivery: Data.Delivery | null;
         description: string | null;
         deviceIds: Array<string>;
+        /**
+         * Compatibility projection of lifecycleStatus; true only when lifecycleStatus is
+         * enabled.
+         */
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
         lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
+        lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
         notifyOnFailure: boolean;
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        /**
+         * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
+         * recordingEnabled=true, "off" = recordingEnabled=false).
+         */
         recordingEnabled: boolean;
+        recordingPolicy: Data.RecordingPolicy;
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
         /**
          * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
          * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
-         * a whole-token null stays JSON null). Existing flows stay 1; new flows default
-         * to 2.
+         * a whole-token null stays JSON null). 3 = typed, key-based (steps are addressed
+         * as {{steps.<key>...}} instead of by name; trigger.payload is not available).
+         * Existing flows stay 1; new flows default to the current version.
          */
         templateResolutionVersion: number;
         triggerId: string;
@@ -287,6 +569,50 @@ export declare namespace FlowCloneResponse {
          */
         userId: string;
     }
+    namespace Data {
+        interface Delivery {
+            destination: 'one_drive' | 'google_drive';
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
+        }
+    }
+}
+export interface FlowDeliveryOptionsResponse {
+    data: FlowDeliveryOptionsResponse.Data;
+}
+export declare namespace FlowDeliveryOptionsResponse {
+    interface Data {
+        canDeliverRecording: boolean;
+        /**
+         * Delivery destinations in registry order.
+         */
+        destinations: Array<Data.Destination>;
+        directUploadStep: Data.DirectUploadStep | null;
+        hasFilesUpload: boolean;
+        recordingMode: 'off' | 'flow' | 'selected_steps';
+    }
+    namespace Data {
+        interface Destination {
+            connection: 'connected' | 'not_connected' | 'expired' | 'unknown';
+            connectKey: string;
+            iconUrl: string | null;
+            key: 'one_drive' | 'google_drive';
+            label: string;
+        }
+        interface DirectUploadStep {
+            flowActionId: string;
+            name: string;
+        }
+    }
 }
 export interface FlowDryRunResponse {
     data: FlowDryRunResponse.Data;
@@ -305,9 +631,12 @@ export declare namespace FlowDryRunResponse {
     namespace Data {
         interface Action {
             continueOnError: boolean;
+            flowActionId: string;
+            key: string;
             method: string;
             name: string;
-            service: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks';
+            recordingEnabled: boolean;
+            service: 'tasks_api' | 'devices_api' | 'agents_api' | 'webhooks' | 'integrations_api';
             /**
              * Nested child actions (loop/branch bodies), each the same shape as a
              * ResolvedAction.
@@ -369,39 +698,96 @@ export declare namespace FlowListRepairsResponse {
         }
     }
 }
+export interface FlowRunResponse {
+    data: FlowRunResponse.Data;
+}
+export declare namespace FlowRunResponse {
+    interface Data {
+        enqueuedCount: number;
+        /**
+         * Ids of the executions this run created. An idempotent replay returns the ids of
+         * the original run.
+         */
+        executionIds: Array<string>;
+    }
+}
+export interface FlowTemplateContextResponse {
+    data: FlowTemplateContextResponse.Data;
+}
+export declare namespace FlowTemplateContextResponse {
+    interface Data {
+        grammar: string;
+        loop: Data.Loop;
+        payloadAliases: Array<string>;
+        roots: Array<Data.Root>;
+        stepReference: Data.StepReference;
+        templateResolutionVersion: number;
+    }
+    namespace Data {
+        interface Loop {
+            context: Array<string>;
+            itemVariableDefault: string;
+            name: string;
+        }
+        interface Root {
+            description: string;
+            name: string;
+            shape?: unknown;
+        }
+        interface StepReference {
+            note: string;
+            pattern: string;
+            keyRule?: string;
+            slugRule?: string;
+        }
+    }
+}
 export interface FlowUnblockResponse {
     data: FlowUnblockResponse.Data;
 }
 export declare namespace FlowUnblockResponse {
     interface Data {
         id: string;
+        archivedAt: string | null;
         blockedAt: string | null;
         consecutiveFailures: number;
         cooldownScope: 'flow' | 'device';
         cooldownSeconds: number | null;
         createdAt: string | null;
         createdBy: string | null;
+        delivery: Data.Delivery | null;
         description: string | null;
         deviceIds: Array<string>;
+        /**
+         * Compatibility projection of lifecycleStatus; true only when lifecycleStatus is
+         * enabled.
+         */
         enabled: boolean;
         healthMonitoringEnabled: boolean;
         lastFailureAt: string | null;
         lastFailureCode: 'device_not_found' | 'permission_denied' | 'client_error' | 'transient' | 'logic' | 'invalid_config' | null;
         lastTriggeredAt: string | null;
+        lifecycleStatus: 'enabled' | 'disabled' | 'archived';
         name: string;
         notifyOnFailure: boolean;
         notifyOnSuccess: boolean;
         notifyWebhookId: string | null;
         ownerId: string;
+        /**
+         * @deprecated Deprecated: use recordingPolicy.mode ("flow" =
+         * recordingEnabled=true, "off" = recordingEnabled=false).
+         */
         recordingEnabled: boolean;
+        recordingPolicy: Data.RecordingPolicy;
         selfHealingEnabled: boolean;
         selfHealingMaxAttempts: number;
         status: 'healthy' | 'failing' | 'blocked';
         /**
          * Template-resolver semantics this flow runs under (MVA-23). 1 = legacy
          * (missing/forbidden/null all resolve to ''). 2 = typed (missing/forbidden throw,
-         * a whole-token null stays JSON null). Existing flows stay 1; new flows default
-         * to 2.
+         * a whole-token null stays JSON null). 3 = typed, key-based (steps are addressed
+         * as {{steps.<key>...}} instead of by name; trigger.payload is not available).
+         * Existing flows stay 1; new flows default to the current version.
          */
         templateResolutionVersion: number;
         triggerId: string;
@@ -411,6 +797,70 @@ export declare namespace FlowUnblockResponse {
          */
         userId: string;
     }
+    namespace Data {
+        interface Delivery {
+            destination: 'one_drive' | 'google_drive';
+            folder?: string;
+            recording?: Delivery.Recording;
+            screenshots?: unknown;
+        }
+        namespace Delivery {
+            interface Recording {
+                filename: string;
+            }
+        }
+        interface RecordingPolicy {
+            mode: 'off' | 'flow' | 'selected_steps';
+        }
+    }
+}
+export interface FlowValidateResponse {
+    data: FlowValidateResponse.Data;
+}
+export declare namespace FlowValidateResponse {
+    interface Data {
+        errors: Array<Data.Error>;
+        valid: boolean;
+        warnings: Array<Data.Warning>;
+    }
+    namespace Data {
+        interface Error {
+            code: string;
+            field: string;
+            message: string;
+            knownSteps?: Array<string>;
+            reference?: string;
+        }
+        interface Warning {
+            code: string;
+            message: string;
+            connectKey?: string;
+            destination?: string;
+        }
+    }
+}
+export interface FlowVerifyResponse {
+    data: FlowVerifyResponse.Data;
+}
+export declare namespace FlowVerifyResponse {
+    interface Data {
+        /**
+         * True when this run already existed for the (flow, invocationId) key (HTTP 200);
+         * false for a newly enqueued run (HTTP 202).
+         */
+        deduplicated: boolean;
+        /**
+         * Device the verification runs on; null for a device-free verification (a 0-device
+         * flow whose actions are all device-free allowlisted).
+         */
+        deviceId: string | null;
+        executionId: string;
+        flowId: string;
+        invocationId: string;
+        kind: 'verification';
+        status: 'pending' | 'running' | 'success' | 'failed' | 'cancelled' | 'skipped' | 'invalid';
+        triggerId: string;
+    }
 }
 export interface FlowCreateParams {
     actions: Array<FlowCreateParams.Action>;
@@ -418,6 +868,7 @@ export interface FlowCreateParams {
     triggerId: string;
     cooldownScope?: 'flow' | 'device';
     cooldownSeconds?: number | null;
+    delivery?: FlowCreateParams.Delivery;
     description?: string;
     deviceIds?: Array<string>;
     enabled?: boolean;
@@ -426,6 +877,7 @@ export interface FlowCreateParams {
     notifyOnSuccess?: boolean;
     notifyWebhookId?: string | null;
     recordingEnabled?: boolean;
+    recordingPolicy?: FlowCreateParams.RecordingPolicy;
     selfHealingEnabled?: boolean;
     selfHealingMaxAttempts?: number;
 }
@@ -435,16 +887,34 @@ export declare namespace FlowCreateParams {
         position: number;
         children?: Array<Action.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?: Action.Overrides | null;
+        recordingEnabled?: boolean;
     }
     namespace Action {
         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 {
@@ -459,23 +929,63 @@ export declare namespace FlowCreateParams {
             };
         }
     }
+    interface Delivery {
+        destination: 'one_drive' | 'google_drive';
+        folder?: string;
+        recording?: Delivery.Recording;
+        screenshots?: unknown;
+    }
+    namespace Delivery {
+        interface Recording {
+            filename: string;
+        }
+    }
+    interface RecordingPolicy {
+        mode: 'off' | 'flow' | 'selected_steps';
+    }
 }
 export interface FlowUpdateParams {
     cooldownScope?: 'flow' | 'device';
     cooldownSeconds?: number | null;
+    delivery?: FlowUpdateParams.Delivery | null;
     description?: string;
     deviceIds?: Array<string>;
     enabled?: boolean;
     healthMonitoringEnabled?: boolean;
+    /**
+     * Set the visible agent lifecycle. Archive remains available only through DELETE.
+     */
+    lifecycleStatus?: 'enabled' | 'disabled';
     name?: string;
     notifyOnFailure?: boolean;
     notifyOnSuccess?: boolean;
     notifyWebhookId?: string | null;
+    /**
+     * @deprecated Deprecated compatibility field. true maps to
+     * recordingPolicy.mode="flow"; false maps to "off".
+     */
     recordingEnabled?: boolean;
+    recordingPolicy?: FlowUpdateParams.RecordingPolicy;
     selfHealingEnabled?: boolean;
     selfHealingMaxAttempts?: number;
     triggerId?: string;
 }
+export declare namespace FlowUpdateParams {
+    interface Delivery {
+        destination: 'one_drive' | 'google_drive';
+        folder?: string;
+        recording?: Delivery.Recording;
+        screenshots?: unknown;
+    }
+    namespace Delivery {
+        interface Recording {
+            filename: string;
+        }
+    }
+    interface RecordingPolicy {
+        mode: 'off' | 'flow' | 'selected_steps';
+    }
+}
 export interface FlowListParams {
     createdBy?: string;
     /**
@@ -494,6 +1004,9 @@ export interface FlowListParams {
     status?: Array<'healthy' | 'failing' | 'blocked'>;
     triggerId?: string;
 }
+export interface FlowActivateParams {
+    verificationExecutionId: string;
+}
 export interface FlowCloneParams {
     deviceIds?: Array<string>;
     name?: string;
@@ -503,8 +1016,146 @@ export interface FlowDryRunParams {
         [key: string]: unknown;
     };
 }
+export interface FlowRunParams {
+    payload?: {
+        [key: string]: unknown;
+    };
+}
+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 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;
+        recordingEnabled?: boolean;
+    }
+    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 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: 'one_drive' | 'google_drive';
+        folder?: string;
+        recording?: Delivery.Recording;
+        screenshots?: unknown;
+    }
+    namespace Delivery {
+        interface Recording {
+            filename: string;
+        }
+    }
+    interface RecordingPolicy {
+        mode: 'off' | 'flow' | 'selected_steps';
+    }
+}
+export interface FlowVerifyParams {
+    /**
+     * Client-supplied idempotency key. A repeat request for the same (flow,
+     * invocationId) returns the existing verification run (`deduplicated: true`,
+     * HTTP 200) instead of enqueuing another.
+     */
+    invocationId: string;
+    /**
+     * Device to run the verification on. Must be one the flow is bound to. Optional
+     * only when the flow is bound to exactly one device (that device is used);
+     * otherwise required.
+     */
+    deviceId?: string;
+    payload?: {
+        [key: string]: unknown;
+    };
+}
 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 FlowCloneResponse as FlowCloneResponse, type FlowDryRunResponse as FlowDryRunResponse, type FlowListRepairsResponse as FlowListRepairsResponse, type FlowUnblockResponse as FlowUnblockResponse, type FlowCreateParams as FlowCreateParams, type FlowUpdateParams as FlowUpdateParams, type FlowListParams as FlowListParams, type FlowCloneParams as FlowCloneParams, type FlowDryRunParams as FlowDryRunParams, };
+    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 FlowCloneParams as FlowCloneParams, type FlowDryRunParams as FlowDryRunParams, 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, };
 }
 //# sourceMappingURL=flows.d.mts.map