Crate dex_sdk 

Strongly typed Rust client and worker APIs for durable Dex Flows.

Define Flow and Step implementations, register them with Registry, host them with Worker, and control executions with Client. The crate also exposes typed Attributes, Channels, waits, decisions, RPCs, lifecycle options, and structured errors.

Structs

Attribute

Defines one durable, typed value stored with a Flow.

AttributeIndex

Describes how Dex projects an Attribute value into its Flow-search index.

AttributeMap

Defines keyed durable values sharing one Attribute name.

AttributeMapLoad

Selects one AttributeMap instance to load for a handler invocation.

BlobCache

Stores immutable Dex blob payloads in a bounded local directory.

BlobCacheConfig

Configures one persistent crate::BlobCache.

BufferedTextStream

Batches text chunks during one Step invocation.

BufferedTextStreamOptions

Configures an invocation-managed buffered text Stream writer.

Channel

Defines one durable FIFO queue of typed messages.

ChannelGuard

Identifies a Channel or Channel-map instance that must be empty before conditional completion.

ChannelMap

Defines independently queued Channel instances under one name.

ChannelMapLoad

Selects one ChannelMap instance’s pending messages for a handler invocation.

ChannelMessage

Identifies one typed value that is still pending in a Channel.

Client

Provides blocking, typed control of registered Dex Flows.

ClientOptions

Configures how a crate::Client reaches Dex and identifies application workers.

Condition

Represents one durable timer, Channel, or SubFlow predicate.

ConditionCombination

Groups conditions that must all succeed as one branch of Wait::any_combination_of.

Context

Provides invocation metadata and staged durable changes to Step and RPC handlers.

FlowConfig

Overrides runtime behavior for one Flow.

FlowInfo

Summarizes one Flow run returned by crate::Client::describe_flow.

FlowResult

Describes an observed Flow status and its output-bearing completions.

FlowTimeoutHandlerFailure

Routes exhausted Flow timeout-handler retries to an input-free Step.

FlowTimeoutHandlerOptions

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

HandlerError

Reports an application-defined Step or RPC failure to Dex.

PersistenceSchema

Declares the Attributes, Channels, and Streams a Flow owns.

RecoveryErrorInfo

Describes the final failure that caused a Step method recovery.

Registry

Validates and stores all Flow definitions used by a Client or Worker.

RetryPolicy

Overrides Dex retry timing for a Flow, wait_for, or execute operation.

Rpc

Names one typed RPC exposed by a Flow.

RpcDefinition

Adds execution options to a typed Rpc before handler binding.

RpcList

Binds typed RPC definitions to methods on one Flow type.

RpcResult

Carries a typed RPC output and optional Step movements.

SearchFlowEntry

Contains one Flow row returned by a search query.

SearchFlowsPage

Contains one page of crate::Client::search_flows results.

ServiceError

Preserves one failed Dex service operation and its transport source.

StartFlowOptions

Configures a new Flow execution.

StepCompletion

Contains one output-bearing Step completion returned by crate::Client::wait_for_flow.

StepDecision

Describes the durable outcome of one successful Step execution.

StepExecutionId

Identifies one execution of a Step type within a Flow run.

StepList

Collects a Flow’s starting Step and remaining Step definitions.

StepMovement

Targets a Step with encoded input and an optional per-movement options override.

StepOptions

Configures one Step’s handler execution and persistence behavior.

StopFlowOptions

Selects how crate::Client::stop_flow ends an active Flow.

Stream

Defines a typed best-effort resumable message Stream owned by one Flow type.

StreamMessage

Describes one retained Stream message returned by crate::Client::read_stream.

SubFlow

Creates durable SubFlow Conditions and reads their Execute results.

SubFlowOptions

Configures one durable SubFlow Condition.

TimeTravelOptions

Selects a historical point from which crate::Client::time_travel creates a new run.

Timer

Creates durable timer conditions for Step waits.

Wait

Describes when Dex may invoke a Step’s execute handler.

Worker

Hosts registered Flow Step and RPC handlers over application WorkerService.

WorkerError

Preserves the original Worker-side error carried by a service failure.

WorkerOptions

Configures a crate::Worker listener and its Dex connection.

WorkerTarget

Identifies the application WorkerService endpoint Dex should call.

Enums

ActiveStepSearchMode

Controls which active Step types Dex indexes for Flow search.

ErrorSubStatus

Provides Dex-specific detail beyond a gRPC status code.

FlowErrorType

Categorizes the failure recorded for an uncompleted Flow.

FlowStatus

Describes the current or terminal state of a Flow run.

FlowTimeoutPolicy

Controls how Dex responds when a positive soft Flow timeout expires.

GrpcCode

gRPC status codes used by Status.

IdReusePolicy

Controls whether crate::Client::start_flow_with_options may reuse a Flow ID.

SdkError

Reports service, definition, value, handler, and Flow-completion failures.

StepDurability

Controls when staged Step persistence must be durably acknowledged.

SubFlowReusePolicy

Controls how a generated SubFlow Flow ID resolves an existing execution.

TimeTravelStepMethod

Selects the Step method used as a Step execution time travel boundary.

TimerId

Selects one timer from a Step execution for crate::Client::skip_timer.

WaitForFailurePolicy

Selects the terminal behavior after wait_for exhausts its retry policy.

Traits

Flow

Defines a durable application Flow and its registered API surface.

Step

Defines one durable state transition in a Flow.

Value

Marks application values that Dex can serialize as JSON and move across handler boundaries.

Type Aliases

FlowTimeoutHandler

Function registered by a Flow to handle expiration of its soft timeout.

HandlerResult

Result returned by application Step and RPC handlers.

SdkResult

Result returned by fallible Dex SDK operations.