Struct StartFlowOptions 

pub struct StartFlowOptions { /* private fields */ }

Configures a new Flow execution.

All optional fields are absent by default. Initial Attribute values are encoded when the start request is sent. Use a stable request ID to make retries of the same logical request idempotent.

A stable request ID alone does not make a retry succeed. Set StartFlowOptions::request_id and StartFlowOptions::ignore_already_started together, and reuse the same values on every retry of one logical start, for example after a lost response.

Examples

use dex_sdk::{Attribute, IdReusePolicy, StartFlowOptions};
use std::time::Duration;

let customer = Attribute::<String>::new("customer");
let options = StartFlowOptions::new()
    .timeout(Duration::from_secs(3_600))
    .id_reuse_policy(IdReusePolicy::AllowIfNotRunning)
    .initial_attribute(&customer, "customer-42".to_owned())
    .request_id("create-order-42");

Retry-safe start options:

use dex_sdk::StartFlowOptions;

let order_id = "42";
let options = StartFlowOptions::new()
    .ignore_already_started(true)
    .request_id(format!("start-order-{order_id}"));

Implementations

impl StartFlowOptions

pub fn new() -> Self

Creates start options that preserve all server defaults.

pub fn timeout(self, value: Duration) -> Self

Sets Dex’s durable soft timeout. A zero duration disables it.

pub fn timeout_policy(self, value: FlowTimeoutPolicy) -> Self

Sets the action taken when the positive Flow timeout expires.

Handler is rejected before start when the registered Flow has no timeout handler.

pub fn timeout_handler_options(self, value: FlowTimeoutHandlerOptions) -> Self

Configures execution and selective state loading for the Flow timeout handler.

Dex rejects this option unless the Flow has a positive timeout and resolves to FlowTimeoutPolicy::Handler.

pub fn start_delay(self, value: Duration) -> Self

Sets a delay before the first Step after the server accepts the Flow.

The Server currently supports only a zero delay. It rejects a positive delay with INVALID_ARGUMENT. To start later, call crate::Client::start_flow at the desired time or wait for a Timer in the starting Step.

pub fn id_reuse_policy(self, value: IdReusePolicy) -> Self

Sets how the server handles an existing Flow with the same ID.

pub fn retry_policy(self, value: RetryPolicy) -> Self

Sets a whole-Flow retry policy for the request.

The Server does not support whole-Flow retry. It rejects a request that sets this option with INVALID_ARGUMENT. Configure crate::RetryPolicy on Step methods through crate::StepOptions instead.

pub fn initial_attribute<T: Value>( self, attribute: &Attribute<T>, value: T, ) -> Self

Adds an initial value for a declared Attribute.

pub fn initial_attribute_map<T: Value>( self, attribute: &AttributeMap<T>, instance: &str, value: T, ) -> Self

Adds an initial value for one Attribute-map instance. Slash is prohibited in instance keys because it is a reserved character.

pub fn config_override(self, value: FlowConfig) -> Self

Overrides the registered Flow configuration for this execution.

pub fn ignore_already_started(self, value: bool) -> Self

Returns the existing run ID instead of an error when the Flow already exists.

It applies only when StartFlowOptions::request_id matches the request ID that started the existing run. A different or generated request ID still returns SdkError::FlowAlreadyStarted. See StartFlowOptions for an example that sets both options.

pub fn request_id(self, value: impl Into<String>) -> Self

Sets the idempotency key for this start request.

When omitted, the SDK generates a new request ID for every call. A retried start returns the existing run only when StartFlowOptions::ignore_already_started is true and this request ID matches the request that started that run. Without that option, the retry returns SdkError::FlowAlreadyStarted even when the first attempt created the Flow. The match applies only when the ID reuse policy rejects the start. A policy that permits another run starts a new run instead. Dex compares only request IDs, not input or other options, so never reuse a request ID for a different logical start. See StartFlowOptions for an example that sets both options.

Trait Implementations

impl Clone for StartFlowOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for StartFlowOptions

fn default() -> Self

Returns the “default value” for a type.