telega/flow/builder

add_conditional

pub fn add_conditional(
  builder: FlowBuilder(step_type, session, error),
  from: step_type,
  condition: fn(types.FlowInstance) -> Bool,
  true on_true: step_type,
  false on_false: step_type,
) -> FlowBuilder(step_type, session, error)

Add conditional transition

add_global_middleware

</>

pub fn add_global_middleware(
  builder: FlowBuilder(step_type, session, error),
  middleware: fn(
    bot.Context(session, error),
    types.FlowInstance,
    fn() -> Result(
      #(
        bot.Context(session, error),
        types.FlowAction(step_type),
        types.FlowInstance,
      ),
      error,
    ),
  ) -> Result(
    #(
      bot.Context(session, error),
      types.FlowAction(step_type),
      types.FlowInstance,
    ),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Add global middleware that applies to all steps

add_multi_conditional

</>

pub fn add_multi_conditional(
  builder: FlowBuilder(step_type, session, error),
  from: step_type,
  conditions: List(#(fn(types.FlowInstance) -> Bool, step_type)),
  default: step_type,
) -> FlowBuilder(step_type, session, error)

Add multi-way conditional

add_parallel_steps

</>

pub fn add_parallel_steps(
  builder: FlowBuilder(step_type, session, error),
  trigger_step: step_type,
  parallel_steps: List(step_type),
  join_at: step_type,
) -> FlowBuilder(step_type, session, error)

Add parallel step execution.

@deprecated Use parallel() instead for cleaner API.

add_step

</>

pub fn add_step(
  builder: FlowBuilder(step_type, session, error),
  step: step_type,
  handler: fn(bot.Context(session, error), types.FlowInstance) -> Result(
    #(
      bot.Context(session, error),
      types.FlowAction(step_type),
      types.FlowInstance,
    ),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Add a step to the flow

add_step_with_hooks

</>

pub fn add_step_with_hooks(
  builder: FlowBuilder(step_type, session, error),
  step: step_type,
  handler handler: fn(
    bot.Context(session, error),
    types.FlowInstance,
  ) -> Result(
    #(
      bot.Context(session, error),
      types.FlowAction(step_type),
      types.FlowInstance,
    ),
    error,
  ),
  on_enter on_enter: option.Option(
    fn(bot.Context(session, error), types.FlowInstance) -> Result(
      #(bot.Context(session, error), types.FlowInstance),
      error,
    ),
  ),
  on_leave on_leave: option.Option(
    fn(bot.Context(session, error), types.FlowInstance) -> Result(
      #(bot.Context(session, error), types.FlowInstance),
      error,
    ),
  ),
) -> FlowBuilder(step_type, session, error)

Add a step with lifecycle hooks

add_step_with_hooks_and_middleware

</>

pub fn add_step_with_hooks_and_middleware(
  builder: FlowBuilder(step_type, session, error),
  step: step_type,
  handler handler: fn(
    bot.Context(session, error),
    types.FlowInstance,
  ) -> Result(
    #(
      bot.Context(session, error),
      types.FlowAction(step_type),
      types.FlowInstance,
    ),
    error,
  ),
  middlewares middlewares: List(
    fn(
      bot.Context(session, error),
      types.FlowInstance,
      fn() -> Result(
        #(
          bot.Context(session, error),
          types.FlowAction(step_type),
          types.FlowInstance,
        ),
        error,
      ),
    ) -> Result(
      #(
        bot.Context(session, error),
        types.FlowAction(step_type),
        types.FlowInstance,
      ),
      error,
    ),
  ),
  on_enter on_enter: option.Option(
    fn(bot.Context(session, error), types.FlowInstance) -> Result(
      #(bot.Context(session, error), types.FlowInstance),
      error,
    ),
  ),
  on_leave on_leave: option.Option(
    fn(bot.Context(session, error), types.FlowInstance) -> Result(
      #(bot.Context(session, error), types.FlowInstance),
      error,
    ),
  ),
) -> FlowBuilder(step_type, session, error)

Add a step with hooks and middleware

add_step_with_middleware

</>

pub fn add_step_with_middleware(
  builder: FlowBuilder(step_type, session, error),
  step: step_type,
  middlewares: List(
    fn(
      bot.Context(session, error),
      types.FlowInstance,
      fn() -> Result(
        #(
          bot.Context(session, error),
          types.FlowAction(step_type),
          types.FlowInstance,
        ),
        error,
      ),
    ) -> Result(
      #(
        bot.Context(session, error),
        types.FlowAction(step_type),
        types.FlowInstance,
      ),
      error,
    ),
  ),
  handler: fn(bot.Context(session, error), types.FlowInstance) -> Result(
    #(
      bot.Context(session, error),
      types.FlowAction(step_type),
      types.FlowInstance,
    ),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Add a step with middleware

add_subflow

</>

pub fn add_subflow(
  builder: FlowBuilder(step_type, session, error),
  trigger_step: step_type,
  subflow subflow: types.Flow(dynamic.Dynamic, session, error),
  return_to return_to: step_type,
  map_args map_args: fn(types.FlowInstance) -> dict.Dict(
    String,
    String,
  ),
  map_result map_result: fn(
    dict.Dict(String, String),
    types.FlowInstance,
  ) -> types.FlowInstance,
) -> FlowBuilder(step_type, session, error)

Add sub-flow

build

</>

pub fn build(
  builder: FlowBuilder(step_type, session, error),
  initial initial_step: step_type,
) -> types.Flow(step_type, session, error)

Build the flow

inline_next

</>

pub fn inline_next(
  ctx: bot.Context(session, error),
  instance: types.FlowInstance,
  step_name step_name: String,
) -> Result(
  #(
    bot.Context(session, error),
    types.FlowAction(types.InlineStep),
    types.FlowInstance,
  ),
  error,
)

Navigate to next inline step by name

new

</>

pub fn new(
  flow_name: String,
  storage: types.FlowStorage(error),
  step_to_string: fn(step_type) -> String,
  string_to_step: fn(String) -> Result(step_type, Nil),
) -> FlowBuilder(step_type, session, error)

Create a new flow builder

new_with_default_converters

</>

pub fn new_with_default_converters(
  flow_name: String,
  storage: types.FlowStorage(error),
  steps: List(#(String, step_type)),
) -> FlowBuilder(step_type, session, error)

Create a flow builder with default string conversion (uses string.inspect)

on_complete

</>

pub fn on_complete(
  builder: FlowBuilder(step_type, session, error),
  handler: fn(bot.Context(session, error), types.FlowInstance) -> Result(
    bot.Context(session, error),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Set completion handler

on_error

</>

pub fn on_error(
  builder: FlowBuilder(step_type, session, error),
  handler: fn(
    bot.Context(session, error),
    types.FlowInstance,
    option.Option(error),
  ) -> Result(bot.Context(session, error), error),
) -> FlowBuilder(step_type, session, error)

Set error handler

on_timeout

</>

pub fn on_timeout(
  builder: FlowBuilder(step_type, session, error),
  handler: fn(bot.Context(session, error), types.FlowInstance) -> Result(
    bot.Context(session, error),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Set timeout hook (called when flow or wait expires via lazy check)

parallel

</>

pub fn parallel(
  builder: FlowBuilder(step_type, session, error),
  from from: step_type,
  steps steps: List(step_type),
  join join: step_type,
) -> FlowBuilder(step_type, session, error)

Add parallel step execution (simplified API).

set_on_flow_enter

</>

pub fn set_on_flow_enter(
  builder: FlowBuilder(step_type, session, error),
  hook: fn(bot.Context(session, error), types.FlowInstance) -> Result(
    #(bot.Context(session, error), types.FlowInstance),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Set flow enter hook

set_on_flow_exit

</>

pub fn set_on_flow_exit(
  builder: FlowBuilder(step_type, session, error),
  hook: fn(bot.Context(session, error), types.FlowInstance) -> Result(
    bot.Context(session, error),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Set flow exit hook

set_on_flow_leave

</>

pub fn set_on_flow_leave(
  builder: FlowBuilder(step_type, session, error),
  hook: fn(bot.Context(session, error), types.FlowInstance) -> Result(
    #(bot.Context(session, error), types.FlowInstance),
    error,
  ),
) -> FlowBuilder(step_type, session, error)

Set flow leave hook

with_inline_subflow

</>

pub fn with_inline_subflow(
  builder: FlowBuilder(step_type, session, error),
  name name: String,
  trigger trigger: step_type,
  return_to return_to: step_type,
  initial initial: String,
  steps steps: List(
    #(
      String,
      fn(bot.Context(session, error), types.FlowInstance) -> Result(
        #(
          bot.Context(session, error),
          types.FlowAction(types.InlineStep),
          types.FlowInstance,
        ),
        error,
      ),
    ),
  ),
) -> FlowBuilder(step_type, session, error)

Add an inline subflow defined within the parent flow

with_inline_subflow_mapped

</>

pub fn with_inline_subflow_mapped(
  builder: FlowBuilder(step_type, session, error),
  name name: String,
  trigger trigger: step_type,
  return_to return_to: step_type,
  initial initial: String,
  steps steps: List(
    #(
      String,
      fn(bot.Context(session, error), types.FlowInstance) -> Result(
        #(
          bot.Context(session, error),
          types.FlowAction(types.InlineStep),
          types.FlowInstance,
        ),
        error,
      ),
    ),
  ),
  map_args map_args: fn(types.FlowInstance) -> dict.Dict(
    String,
    String,
  ),
  map_result map_result: fn(
    dict.Dict(String, String),
    types.FlowInstance,
  ) -> types.FlowInstance,
) -> FlowBuilder(step_type, session, error)

Add an inline subflow with custom argument and result mapping

with_ttl

</>

pub fn with_ttl(
  builder: FlowBuilder(step_type, session, error),
  ms ms: Int,
) -> FlowBuilder(step_type, session, error)

Set flow-level TTL (maximum lifetime in milliseconds)

telega - v1.2.0

Types

FlowBuilder

Values