-module(telega@flow@builder).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/telega/flow/builder.gleam").
-export([new/4, new_with_default_converters/3, add_step/3, add_step_with_middleware/4, add_step_with_hooks/5, add_step_with_hooks_and_middleware/6, add_global_middleware/2, add_conditional/5, add_multi_conditional/4, add_parallel_steps/4, parallel/4, add_subflow/6, build/2, with_inline_subflow/6, with_inline_subflow_mapped/8, inline_next/3, on_complete/2, on_error/2, set_on_flow_enter/2, set_on_flow_leave/2, with_ttl/2, on_timeout/2, set_on_flow_exit/2]).
-export_type([flow_builder/4]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(" FlowBuilder and all builder functions for constructing flows.\n").

-opaque flow_builder(AXNK, AXNL, AXNM, AXNN) :: {flow_builder,
        binary(),
        gleam@dict:dict(binary(), telega@flow@types:step_config(AXNK, AXNL, AXNM, AXNN)),
        fun((AXNK) -> binary()),
        fun((binary()) -> {ok, AXNK} | {error, nil}),
        telega@flow@types:flow_storage(AXNM),
        gleam@option:option(fun((telega@bot:context(AXNL, AXNM, AXNN), telega@flow@types:flow_instance()) -> {ok,
                telega@bot:context(AXNL, AXNM, AXNN)} |
            {error, AXNM})),
        gleam@option:option(fun((telega@bot:context(AXNL, AXNM, AXNN), telega@flow@types:flow_instance(), gleam@option:option(AXNM)) -> {ok,
                telega@bot:context(AXNL, AXNM, AXNN)} |
            {error, AXNM})),
        list(fun((telega@bot:context(AXNL, AXNM, AXNN), telega@flow@types:flow_instance(), fun(() -> {ok,
                {telega@bot:context(AXNL, AXNM, AXNN),
                    telega@flow@types:flow_action(AXNK),
                    telega@flow@types:flow_instance()}} |
            {error, AXNM})) -> {ok,
                {telega@bot:context(AXNL, AXNM, AXNN),
                    telega@flow@types:flow_action(AXNK),
                    telega@flow@types:flow_instance()}} |
            {error, AXNM})),
        list(telega@flow@types:conditional_transition(AXNK)),
        list(telega@flow@types:parallel_config(AXNK)),
        list(telega@flow@types:subflow_config(AXNK, AXNL, AXNM, AXNN)),
        gleam@option:option(fun((telega@bot:context(AXNL, AXNM, AXNN), telega@flow@types:flow_instance()) -> {ok,
                {telega@bot:context(AXNL, AXNM, AXNN),
                    telega@flow@types:flow_instance()}} |
            {error, AXNM})),
        gleam@option:option(fun((telega@bot:context(AXNL, AXNM, AXNN), telega@flow@types:flow_instance()) -> {ok,
                {telega@bot:context(AXNL, AXNM, AXNN),
                    telega@flow@types:flow_instance()}} |
            {error, AXNM})),
        gleam@option:option(fun((telega@bot:context(AXNL, AXNM, AXNN), telega@flow@types:flow_instance()) -> {ok,
                telega@bot:context(AXNL, AXNM, AXNN)} |
            {error, AXNM})),
        gleam@option:option(integer()),
        gleam@option:option(fun((telega@bot:context(AXNL, AXNM, AXNN), telega@flow@types:flow_instance()) -> {ok,
                telega@bot:context(AXNL, AXNM, AXNN)} |
            {error, AXNM}))}.

-file("src/telega/flow/builder.gleam", 51).
?DOC(" Create a new flow builder\n").
-spec new(
    binary(),
    telega@flow@types:flow_storage(AXNO),
    fun((AXNQ) -> binary()),
    fun((binary()) -> {ok, AXNQ} | {error, nil})
) -> flow_builder(AXNQ, any(), AXNO, any()).
new(Flow_name, Storage, Step_to_string, String_to_step) ->
    {flow_builder,
        Flow_name,
        maps:new(),
        Step_to_string,
        String_to_step,
        Storage,
        none,
        none,
        [],
        [],
        [],
        [],
        none,
        none,
        none,
        none,
        none}.

-file("src/telega/flow/builder.gleam", 459).
?DOC(" Helper to create a string_to_step function for a list of steps\n").
-spec create_string_to_step(list({binary(), AYCD})) -> fun((binary()) -> {ok,
        AYCD} |
    {error, nil}).
create_string_to_step(Steps) ->
    Step_dict = maps:from_list(Steps),
    fun(Name) -> gleam_stdlib:map_get(Step_dict, Name) end.

-file("src/telega/flow/builder.gleam", 78).
?DOC(" Create a flow builder with default string conversion (uses string.inspect)\n").
-spec new_with_default_converters(
    binary(),
    telega@flow@types:flow_storage(AXNZ),
    list({binary(), AXOB})
) -> flow_builder(AXOB, any(), AXNZ, any()).
new_with_default_converters(Flow_name, Storage, Steps) ->
    {flow_builder,
        Flow_name,
        maps:new(),
        fun gleam@string:inspect/1,
        create_string_to_step(Steps),
        Storage,
        none,
        none,
        [],
        [],
        [],
        [],
        none,
        none,
        none,
        none,
        none}.

-file("src/telega/flow/builder.gleam", 104).
?DOC(" Add a step to the flow\n").
-spec add_step(
    flow_builder(AXOJ, AXOK, AXOL, AXOM),
    AXOJ,
    fun((telega@bot:context(AXOK, AXOL, AXOM), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXOK, AXOL, AXOM),
                telega@flow@types:flow_action(AXOJ),
                telega@flow@types:flow_instance()}} |
        {error, AXOL})
) -> flow_builder(AXOJ, AXOK, AXOL, AXOM).
add_step(Builder, Step, Handler) ->
    Step_name = (erlang:element(4, Builder))(Step),
    Config = {step_config, Handler, [], none, none},
    {flow_builder,
        erlang:element(2, Builder),
        gleam@dict:insert(erlang:element(3, Builder), Step_name, Config),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 116).
?DOC(" Add a step with middleware\n").
-spec add_step_with_middleware(
    flow_builder(AXOZ, AXPA, AXPB, AXPC),
    AXOZ,
    list(fun((telega@bot:context(AXPA, AXPB, AXPC), telega@flow@types:flow_instance(), fun(() -> {ok,
            {telega@bot:context(AXPA, AXPB, AXPC),
                telega@flow@types:flow_action(AXOZ),
                telega@flow@types:flow_instance()}} |
        {error, AXPB})) -> {ok,
            {telega@bot:context(AXPA, AXPB, AXPC),
                telega@flow@types:flow_action(AXOZ),
                telega@flow@types:flow_instance()}} |
        {error, AXPB})),
    fun((telega@bot:context(AXPA, AXPB, AXPC), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXPA, AXPB, AXPC),
                telega@flow@types:flow_action(AXOZ),
                telega@flow@types:flow_instance()}} |
        {error, AXPB})
) -> flow_builder(AXOZ, AXPA, AXPB, AXPC).
add_step_with_middleware(Builder, Step, Middlewares, Handler) ->
    Step_name = (erlang:element(4, Builder))(Step),
    Config = {step_config, Handler, Middlewares, none, none},
    {flow_builder,
        erlang:element(2, Builder),
        gleam@dict:insert(erlang:element(3, Builder), Step_name, Config),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 129).
?DOC(" Add a step with lifecycle hooks\n").
-spec add_step_with_hooks(
    flow_builder(AXPU, AXPV, AXPW, AXPX),
    AXPU,
    fun((telega@bot:context(AXPV, AXPW, AXPX), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXPV, AXPW, AXPX),
                telega@flow@types:flow_action(AXPU),
                telega@flow@types:flow_instance()}} |
        {error, AXPW}),
    gleam@option:option(fun((telega@bot:context(AXPV, AXPW, AXPX), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXPV, AXPW, AXPX),
                telega@flow@types:flow_instance()}} |
        {error, AXPW})),
    gleam@option:option(fun((telega@bot:context(AXPV, AXPW, AXPX), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXPV, AXPW, AXPX),
                telega@flow@types:flow_instance()}} |
        {error, AXPW}))
) -> flow_builder(AXPU, AXPV, AXPW, AXPX).
add_step_with_hooks(Builder, Step, Handler, On_enter, On_leave) ->
    Step_name = (erlang:element(4, Builder))(Step),
    Config = {step_config, Handler, [], On_enter, On_leave},
    {flow_builder,
        erlang:element(2, Builder),
        gleam@dict:insert(erlang:element(3, Builder), Step_name, Config),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 142).
?DOC(" Add a step with hooks and middleware\n").
-spec add_step_with_hooks_and_middleware(
    flow_builder(AXQS, AXQT, AXQU, AXQV),
    AXQS,
    fun((telega@bot:context(AXQT, AXQU, AXQV), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXQT, AXQU, AXQV),
                telega@flow@types:flow_action(AXQS),
                telega@flow@types:flow_instance()}} |
        {error, AXQU}),
    list(fun((telega@bot:context(AXQT, AXQU, AXQV), telega@flow@types:flow_instance(), fun(() -> {ok,
            {telega@bot:context(AXQT, AXQU, AXQV),
                telega@flow@types:flow_action(AXQS),
                telega@flow@types:flow_instance()}} |
        {error, AXQU})) -> {ok,
            {telega@bot:context(AXQT, AXQU, AXQV),
                telega@flow@types:flow_action(AXQS),
                telega@flow@types:flow_instance()}} |
        {error, AXQU})),
    gleam@option:option(fun((telega@bot:context(AXQT, AXQU, AXQV), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXQT, AXQU, AXQV),
                telega@flow@types:flow_instance()}} |
        {error, AXQU})),
    gleam@option:option(fun((telega@bot:context(AXQT, AXQU, AXQV), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXQT, AXQU, AXQV),
                telega@flow@types:flow_instance()}} |
        {error, AXQU}))
) -> flow_builder(AXQS, AXQT, AXQU, AXQV).
add_step_with_hooks_and_middleware(
    Builder,
    Step,
    Handler,
    Middlewares,
    On_enter,
    On_leave
) ->
    Step_name = (erlang:element(4, Builder))(Step),
    Config = {step_config, Handler, Middlewares, On_enter, On_leave},
    {flow_builder,
        erlang:element(2, Builder),
        gleam@dict:insert(erlang:element(3, Builder), Step_name, Config),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 158).
?DOC(" Add global middleware that applies to all steps\n").
-spec add_global_middleware(
    flow_builder(AXRV, AXRW, AXRX, AXRY),
    fun((telega@bot:context(AXRW, AXRX, AXRY), telega@flow@types:flow_instance(), fun(() -> {ok,
            {telega@bot:context(AXRW, AXRX, AXRY),
                telega@flow@types:flow_action(AXRV),
                telega@flow@types:flow_instance()}} |
        {error, AXRX})) -> {ok,
            {telega@bot:context(AXRW, AXRX, AXRY),
                telega@flow@types:flow_action(AXRV),
                telega@flow@types:flow_instance()}} |
        {error, AXRX})
) -> flow_builder(AXRV, AXRW, AXRX, AXRY).
add_global_middleware(Builder, Middleware) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        lists:append(erlang:element(9, Builder), [Middleware]),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 169).
?DOC(" Add conditional transition\n").
-spec add_conditional(
    flow_builder(AXSL, AXSM, AXSN, AXSO),
    AXSL,
    fun((telega@flow@types:flow_instance()) -> boolean()),
    AXSL,
    AXSL
) -> flow_builder(AXSL, AXSM, AXSN, AXSO).
add_conditional(Builder, From, Condition, On_true, On_false) ->
    From_str = (erlang:element(4, Builder))(From),
    Conditional = {conditional_transition,
        From_str,
        [{Condition, On_true}],
        On_false},
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        lists:append(erlang:element(10, Builder), [Conditional]),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 190).
?DOC(" Add multi-way conditional\n").
-spec add_multi_conditional(
    flow_builder(AXSX, AXSY, AXSZ, AXTA),
    AXSX,
    list({fun((telega@flow@types:flow_instance()) -> boolean()), AXSX}),
    AXSX
) -> flow_builder(AXSX, AXSY, AXSZ, AXTA).
add_multi_conditional(Builder, From, Conditions, Default) ->
    From_str = (erlang:element(4, Builder))(From),
    Conditional = {conditional_transition, From_str, Conditions, Default},
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        lists:append(erlang:element(10, Builder), [Conditional]),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 217).
?DOC(
    " Add parallel step execution.\n"
    "\n"
    " @deprecated Use `parallel()` instead for cleaner API.\n"
).
-spec add_parallel_steps(
    flow_builder(AXTX, AXTY, AXTZ, AXUA),
    AXTX,
    list(AXTX),
    AXTX
) -> flow_builder(AXTX, AXTY, AXTZ, AXUA).
add_parallel_steps(Builder, Trigger_step, Parallel_steps, Join_at) ->
    Trigger_str = (erlang:element(4, Builder))(Trigger_step),
    Config = {parallel_config, Trigger_str, Parallel_steps, Join_at},
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        lists:append(erlang:element(11, Builder), [Config]),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 205).
?DOC(" Add parallel step execution (simplified API).\n").
-spec parallel(flow_builder(AXTK, AXTL, AXTM, AXTN), AXTK, list(AXTK), AXTK) -> flow_builder(AXTK, AXTL, AXTM, AXTN).
parallel(Builder, From, Steps, Join) ->
    add_parallel_steps(Builder, From, Steps, Join).

-file("src/telega/flow/builder.gleam", 237).
?DOC(" Add sub-flow\n").
-spec add_subflow(
    flow_builder(AXUK, AXUL, AXUM, AXUN),
    AXUK,
    telega@flow@types:flow(gleam@dynamic:dynamic_(), AXUL, AXUM, AXUN),
    AXUK,
    fun((telega@flow@types:flow_instance()) -> gleam@dict:dict(binary(), binary())),
    fun((gleam@dict:dict(binary(), binary()), telega@flow@types:flow_instance()) -> telega@flow@types:flow_instance())
) -> flow_builder(AXUK, AXUL, AXUM, AXUN).
add_subflow(Builder, Trigger_step, Subflow, Return_to, Map_args, Map_result) ->
    Trigger_str = (erlang:element(4, Builder))(Trigger_step),
    Config = {subflow_config,
        Trigger_str,
        Subflow,
        Return_to,
        Map_args,
        Map_result},
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        lists:append(erlang:element(12, Builder), [Config]),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 468).
-spec unsafe_coerce(any()) -> any().
unsafe_coerce(Value) ->
    telega@internal@coerce:unsafe_coerce(Value).

-file("src/telega/flow/builder.gleam", 425).
?DOC(" Build the flow\n").
-spec build(flow_builder(AYBP, AYBQ, AYBR, AYBS), AYBP) -> telega@flow@types:flow(AYBP, AYBQ, AYBR, AYBS).
build(Builder, Initial_step) ->
    {flow,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        Initial_step,
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 454).
-spec string_to_inline_step(binary()) -> {ok, telega@flow@types:inline_step()} |
    {error, nil}.
string_to_inline_step(S) ->
    {ok, {inline_step, S}}.

-file("src/telega/flow/builder.gleam", 450).
-spec inline_step_to_string(telega@flow@types:inline_step()) -> binary().
inline_step_to_string(Step) ->
    erlang:element(2, Step).

-file("src/telega/flow/builder.gleam", 259).
?DOC(" Add an inline subflow defined within the parent flow\n").
-spec with_inline_subflow(
    flow_builder(AXVE, AXVF, AXVG, AXVH),
    binary(),
    AXVE,
    AXVE,
    binary(),
    list({binary(),
        fun((telega@bot:context(AXVF, AXVG, AXVH), telega@flow@types:flow_instance()) -> {ok,
                {telega@bot:context(AXVF, AXVG, AXVH),
                    telega@flow@types:flow_action(telega@flow@types:inline_step()),
                    telega@flow@types:flow_instance()}} |
            {error, AXVG})})
) -> flow_builder(AXVE, AXVF, AXVG, AXVH).
with_inline_subflow(Builder, Name, Trigger, Return_to, Initial, Steps) ->
    Inline_flow_name = <<<<(erlang:element(2, Builder))/binary, "::"/utf8>>/binary,
        Name/binary>>,
    Inline_storage = erlang:element(6, Builder),
    Inline_builder = new(
        Inline_flow_name,
        Inline_storage,
        fun inline_step_to_string/1,
        fun string_to_inline_step/1
    ),
    Inline_builder@1 = gleam@list:fold(
        Steps,
        Inline_builder,
        fun(B, Step_tuple) ->
            {Step_name, Handler} = Step_tuple,
            add_step(B, {inline_step, Step_name}, Handler)
        end
    ),
    Inline_flow = build(Inline_builder@1, {inline_step, Initial}),
    Coerced_flow = unsafe_coerce(Inline_flow),
    add_subflow(
        Builder,
        Trigger,
        Coerced_flow,
        Return_to,
        fun(Instance) -> erlang:element(3, erlang:element(6, Instance)) end,
        fun(Result, Instance@1) ->
            {flow_instance,
                erlang:element(2, Instance@1),
                erlang:element(3, Instance@1),
                erlang:element(4, Instance@1),
                erlang:element(5, Instance@1),
                begin
                    _record = erlang:element(6, Instance@1),
                    {flow_state,
                        erlang:element(2, _record),
                        maps:merge(
                            erlang:element(3, erlang:element(6, Instance@1)),
                            Result
                        ),
                        erlang:element(4, _record),
                        erlang:element(5, _record),
                        erlang:element(6, _record)}
                end,
                erlang:element(7, Instance@1),
                erlang:element(8, Instance@1),
                erlang:element(9, Instance@1),
                erlang:element(10, Instance@1),
                erlang:element(11, Instance@1)}
        end
    ).

-file("src/telega/flow/builder.gleam", 313).
?DOC(" Add an inline subflow with custom argument and result mapping\n").
-spec with_inline_subflow_mapped(
    flow_builder(AXVY, AXVZ, AXWA, AXWB),
    binary(),
    AXVY,
    AXVY,
    binary(),
    list({binary(),
        fun((telega@bot:context(AXVZ, AXWA, AXWB), telega@flow@types:flow_instance()) -> {ok,
                {telega@bot:context(AXVZ, AXWA, AXWB),
                    telega@flow@types:flow_action(telega@flow@types:inline_step()),
                    telega@flow@types:flow_instance()}} |
            {error, AXWA})}),
    fun((telega@flow@types:flow_instance()) -> gleam@dict:dict(binary(), binary())),
    fun((gleam@dict:dict(binary(), binary()), telega@flow@types:flow_instance()) -> telega@flow@types:flow_instance())
) -> flow_builder(AXVY, AXVZ, AXWA, AXWB).
with_inline_subflow_mapped(
    Builder,
    Name,
    Trigger,
    Return_to,
    Initial,
    Steps,
    Map_args,
    Map_result
) ->
    Inline_flow_name = <<<<(erlang:element(2, Builder))/binary, "::"/utf8>>/binary,
        Name/binary>>,
    Inline_storage = erlang:element(6, Builder),
    Inline_builder = new(
        Inline_flow_name,
        Inline_storage,
        fun inline_step_to_string/1,
        fun string_to_inline_step/1
    ),
    Inline_builder@1 = gleam@list:fold(
        Steps,
        Inline_builder,
        fun(B, Step_tuple) ->
            {Step_name, Handler} = Step_tuple,
            add_step(B, {inline_step, Step_name}, Handler)
        end
    ),
    Inline_flow = build(Inline_builder@1, {inline_step, Initial}),
    Coerced_flow = unsafe_coerce(Inline_flow),
    add_subflow(Builder, Trigger, Coerced_flow, Return_to, Map_args, Map_result).

-file("src/telega/flow/builder.gleam", 355).
?DOC(" Navigate to next inline step by name\n").
-spec inline_next(
    telega@bot:context(AXWW, AXWX, AXWY),
    telega@flow@types:flow_instance(),
    binary()
) -> {ok,
        {telega@bot:context(AXWW, AXWX, AXWY),
            telega@flow@types:flow_action(telega@flow@types:inline_step()),
            telega@flow@types:flow_instance()}} |
    {error, AXWX}.
inline_next(Ctx, Instance, Step_name) ->
    {ok, {Ctx, {next, {inline_step, Step_name}}, Instance}}.

-file("src/telega/flow/builder.gleam", 364).
?DOC(" Set completion handler\n").
-spec on_complete(
    flow_builder(AXXG, AXXH, AXXI, AXXJ),
    fun((telega@bot:context(AXXH, AXXI, AXXJ), telega@flow@types:flow_instance()) -> {ok,
            telega@bot:context(AXXH, AXXI, AXXJ)} |
        {error, AXXI})
) -> flow_builder(AXXG, AXXH, AXXI, AXXJ).
on_complete(Builder, Handler) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        {some, Handler},
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 373).
?DOC(" Set error handler\n").
-spec on_error(
    flow_builder(AXYA, AXYB, AXYC, AXYD),
    fun((telega@bot:context(AXYB, AXYC, AXYD), telega@flow@types:flow_instance(), gleam@option:option(AXYC)) -> {ok,
            telega@bot:context(AXYB, AXYC, AXYD)} |
        {error, AXYC})
) -> flow_builder(AXYA, AXYB, AXYC, AXYD).
on_error(Builder, Handler) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        {some, Handler},
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 385).
?DOC(" Set flow enter hook\n").
-spec set_on_flow_enter(
    flow_builder(AXYV, AXYW, AXYX, AXYY),
    fun((telega@bot:context(AXYW, AXYX, AXYY), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXYW, AXYX, AXYY),
                telega@flow@types:flow_instance()}} |
        {error, AXYX})
) -> flow_builder(AXYV, AXYW, AXYX, AXYY).
set_on_flow_enter(Builder, Hook) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        {some, Hook},
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 393).
?DOC(" Set flow leave hook\n").
-spec set_on_flow_leave(
    flow_builder(AXZK, AXZL, AXZM, AXZN),
    fun((telega@bot:context(AXZL, AXZM, AXZN), telega@flow@types:flow_instance()) -> {ok,
            {telega@bot:context(AXZL, AXZM, AXZN),
                telega@flow@types:flow_instance()}} |
        {error, AXZM})
) -> flow_builder(AXZK, AXZL, AXZM, AXZN).
set_on_flow_leave(Builder, Hook) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        {some, Hook},
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 401).
?DOC(" Set flow-level TTL (maximum lifetime in milliseconds)\n").
-spec with_ttl(flow_builder(AXZZ, AYAA, AYAB, AYAC), integer()) -> flow_builder(AXZZ, AYAA, AYAB, AYAC).
with_ttl(Builder, Ms) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        {some, Ms},
        erlang:element(17, Builder)}.

-file("src/telega/flow/builder.gleam", 409).
?DOC(" Set timeout hook (called when flow or wait expires via lazy check)\n").
-spec on_timeout(
    flow_builder(AYAL, AYAM, AYAN, AYAO),
    fun((telega@bot:context(AYAM, AYAN, AYAO), telega@flow@types:flow_instance()) -> {ok,
            telega@bot:context(AYAM, AYAN, AYAO)} |
        {error, AYAN})
) -> flow_builder(AYAL, AYAM, AYAN, AYAO).
on_timeout(Builder, Handler) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        erlang:element(15, Builder),
        erlang:element(16, Builder),
        {some, Handler}}.

-file("src/telega/flow/builder.gleam", 417).
?DOC(" Set flow exit hook\n").
-spec set_on_flow_exit(
    flow_builder(AYBA, AYBB, AYBC, AYBD),
    fun((telega@bot:context(AYBB, AYBC, AYBD), telega@flow@types:flow_instance()) -> {ok,
            telega@bot:context(AYBB, AYBC, AYBD)} |
        {error, AYBC})
) -> flow_builder(AYBA, AYBB, AYBC, AYBD).
set_on_flow_exit(Builder, Hook) ->
    {flow_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder),
        erlang:element(12, Builder),
        erlang:element(13, Builder),
        erlang:element(14, Builder),
        {some, Hook},
        erlang:element(16, Builder),
        erlang:element(17, Builder)}.