-module(formz).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([create_form/1, decode/1, items/1, definition/3, definition_with_custom_optional/5, verify/2, widget/2, get_parse/1, get_optional_parse/1, named/1, set_name/2, set_label/2, set_help_text/2, set_disabled/2, make_disabled/1, limited_list/4, list/3, simple_limit_check/3, limit_at_least/1, limit_at_most/1, limit_between/2, data/2, field/3, required_field/3, subform/3, decode_then_try/2, get/2, validate/2, validate_all/1, update/3, update_config/3, field_error/3, listfield_errors/3, get_states/1]).
-export_type([form/2, item/1, input_state/0, requirement/0, config/0, definition/3, list_parsing_result/1]).

-opaque form(FYC, FYD) :: {form,
        list(item(FYC)),
        fun((list(item(FYC))) -> {ok, FYD} | {error, list(item(FYC))}),
        FYD}.

-type item(FYE) :: {field, config(), input_state(), FYE} |
    {list_field,
        config(),
        list(input_state()),
        fun((integer()) -> {ok, list(input_state())} | {error, integer()}),
        FYE} |
    {sub_form, config(), list(item(FYE))}.

-type input_state() :: {unvalidated, binary(), requirement()} |
    {valid, binary(), requirement()} |
    {invalid, binary(), requirement(), binary()}.

-type requirement() :: optional | required.

-type config() :: {config, binary(), binary(), binary(), boolean()}.

-opaque definition(FYF, FYG, FYH) :: {definition,
        FYF,
        fun((binary()) -> {ok, FYG} | {error, binary()}),
        FYG,
        fun((fun((binary()) -> {ok, FYG} | {error, binary()}), binary()) -> {ok,
                FYH} |
            {error, binary()}),
        FYH}.

-type list_parsing_result(FYI) :: {list_parsing_result,
        binary(),
        requirement(),
        {ok, FYI} | {error, binary()}}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 323).
-spec create_form(FYM) -> form(any(), FYM).
create_form(Thing) ->
    {form, [], fun(_) -> {ok, Thing} end, Thing}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 618).
-spec state_from_parse_result(list_parsing_result(any())) -> input_state().
state_from_parse_result(Result) ->
    {list_parsing_result, Value, Requirement, Output} = Result,
    case Output of
        {ok, _} ->
            {valid, Value, Requirement};

        {error, Error} ->
            {invalid, Value, Requirement, Error}
    end.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 639).
-spec parse_list_state(
    input_state(),
    fun((binary()) -> {ok, GAS} | {error, binary()}),
    GAS
) -> list_parsing_result(GAS).
parse_list_state(State, Parse, Stub) ->
    _pipe = case {erlang:element(2, State), erlang:element(3, State)} of
        {<<""/utf8>>, optional} ->
            {ok, Stub};

        {_, _} ->
            Parse(erlang:element(2, State))
    end,
    {list_parsing_result,
        erlang:element(2, State),
        erlang:element(3, State),
        _pipe}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 651).
-spec mark_above_max_values_as_invalid(
    list(list_parsing_result(GAW)),
    fun((integer()) -> {ok, list(input_state())} | {error, integer()})
) -> list(list_parsing_result(GAW)).
mark_above_max_values_as_invalid(List, Limit_check) ->
    Count = gleam@list:fold(
        List,
        0,
        fun(Acc, R) -> case {erlang:element(2, R), erlang:element(3, R)} of
                {<<""/utf8>>, optional} ->
                    Acc;

                {_, _} ->
                    Acc + 1
            end end
    ),
    case Limit_check(Count) of
        {ok, _} ->
            List;

        {error, Num_too_many} ->
            Max_index = Count - Num_too_many,
            {Mapped_results, _} = gleam@list:fold(
                List,
                {[], 0},
                fun(Acc@1, R@1) ->
                    {Results, I} = Acc@1,
                    case {erlang:element(2, R@1),
                        erlang:element(3, R@1),
                        I >= Max_index} of
                        {<<""/utf8>>, optional, _} ->
                            {[R@1 | Results], I};

                        {_, _, false} ->
                            {[R@1 | Results], I + 1};

                        {V, R@2, true} ->
                            {[{list_parsing_result,
                                        V,
                                        R@2,
                                        {error,
                                            <<"exceeds maximum allowed items"/utf8>>}} |
                                    Results],
                                I + 1}
                    end
                end
            ),
            _pipe = Mapped_results,
            lists:reverse(_pipe)
    end.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 861).
-spec decode(form(GCS, GCT)) -> {ok, GCT} | {error, form(GCS, GCT)}.
decode(Form) ->
    case (erlang:element(3, Form))(erlang:element(2, Form)) of
        {ok, Output} ->
            {ok, Output};

        {error, Items} ->
            {error, erlang:setelement(2, Form, Items)}
    end.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 980).
-spec items(form(GEH, any())) -> list(item(GEH)).
items(Form) ->
    erlang:element(2, Form).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1107).
-spec get_item_name(item(any())) -> binary().
get_item_name(Item) ->
    case Item of
        {field, Field, _, _} ->
            erlang:element(2, Field);

        {list_field, Field@1, _, _, _} ->
            erlang:element(2, Field@1);

        {sub_form, Subform, _} ->
            erlang:element(2, Subform)
    end.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1118).
-spec definition(GGF, fun((binary()) -> {ok, GGG} | {error, binary()}), GGG) -> definition(GGF, GGG, gleam@option:option(GGG)).
definition(Widget, Parse, Stub) ->
    {definition, Widget, Parse, Stub, fun(Fun, Str) -> case Str of
                <<""/utf8>> ->
                    {ok, none};

                _ ->
                    _pipe = Fun(Str),
                    gleam@result:map(_pipe, fun(Field@0) -> {some, Field@0} end)
            end end, none}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1147).
-spec definition_with_custom_optional(
    GGK,
    fun((binary()) -> {ok, GGL} | {error, binary()}),
    GGL,
    fun((fun((binary()) -> {ok, GGL} | {error, binary()}), binary()) -> {ok,
            GGQ} |
        {error, binary()}),
    GGQ
) -> definition(GGK, GGL, GGQ).
definition_with_custom_optional(
    Widget,
    Parse,
    Stub,
    Optional_parse,
    Optional_stub
) ->
    {definition, Widget, Parse, Stub, Optional_parse, Optional_stub}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1176).
-spec verify(
    definition(GGW, GGX, GGY),
    fun((GGX) -> {ok, GGX} | {error, binary()})
) -> definition(GGW, GGX, GGY).
verify(Def, Fun) ->
    erlang:setelement(3, Def, fun(Val) -> _pipe = Val,
            _pipe@1 = (erlang:element(3, Def))(_pipe),
            gleam@result:'try'(_pipe@1, Fun) end).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1222).
-spec widget(definition(GHH, GHI, GHJ), GHH) -> definition(GHH, GHI, GHJ).
widget(Def, Widget) ->
    erlang:setelement(2, Def, Widget).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1230).
-spec get_parse(definition(any(), GHR, any())) -> fun((binary()) -> {ok, GHR} |
    {error, binary()}).
get_parse(Def) ->
    erlang:element(3, Def).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1237).
-spec get_optional_parse(definition(any(), GHZ, GIA)) -> fun((fun((binary()) -> {ok,
        GHZ} |
    {error, binary()}), binary()) -> {ok, GIA} | {error, binary()}).
get_optional_parse(Def) ->
    erlang:element(5, Def).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1271).
-spec named(binary()) -> config().
named(Name) ->
    {config, Name, justin:sentence_case(Name), <<""/utf8>>, false}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1281).
-spec set_name(config(), binary()) -> config().
set_name(Config, Name) ->
    erlang:setelement(2, Config, Name).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 708).
-spec add_prefix_to_item(item(GBN), binary()) -> item(GBN).
add_prefix_to_item(Item, Prefix) ->
    case Item of
        {field, Item_details, State, Widget} ->
            New_name = <<<<Prefix/binary, "-"/utf8>>/binary,
                (erlang:element(2, Item_details))/binary>>,
            {field,
                begin
                    _pipe = Item_details,
                    set_name(_pipe, New_name)
                end,
                State,
                Widget};

        {list_field, Item_details@1, States, Limit_check, Widget@1} ->
            New_name@1 = <<<<Prefix/binary, "-"/utf8>>/binary,
                (erlang:element(2, Item_details@1))/binary>>,
            {list_field,
                begin
                    _pipe@1 = Item_details@1,
                    set_name(_pipe@1, New_name@1)
                end,
                States,
                Limit_check,
                Widget@1};

        {sub_form, Item_details@2, Sub_items} ->
            New_name@2 = <<<<Prefix/binary, "-"/utf8>>/binary,
                (erlang:element(2, Item_details@2))/binary>>,
            {sub_form,
                begin
                    _pipe@2 = Item_details@2,
                    set_name(_pipe@2, New_name@2)
                end,
                Sub_items}
    end.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1287).
-spec set_label(config(), binary()) -> config().
set_label(Config, Label) ->
    erlang:setelement(3, Config, Label).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1292).
-spec set_help_text(config(), binary()) -> config().
set_help_text(Config, Help_text) ->
    erlang:setelement(4, Config, Help_text).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1297).
-spec set_disabled(config(), boolean()) -> config().
set_disabled(Config, Disabled) ->
    erlang:setelement(5, Config, Disabled).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1306).
-spec make_disabled(config()) -> config().
make_disabled(Config) ->
    set_disabled(Config, true).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 535).
-spec limited_list(
    fun((integer()) -> {ok, list(input_state())} | {error, integer()}),
    config(),
    definition(FZY, FZZ, any()),
    fun((list(FZZ)) -> form(FZY, GAF))
) -> form(FZY, GAF).
limited_list(Limit_check, Config, Definition, Next) ->
    Next_form = Next([erlang:element(4, Definition)]),
    Initial_fields = begin
        _pipe = Limit_check(0),
        gleam@result:unwrap(_pipe, [])
    end,
    Updated_items = [{list_field,
            Config,
            Initial_fields,
            Limit_check,
            erlang:element(2, Definition)} |
        erlang:element(2, Next_form)],
    Decode = fun(Items) ->
        [{list_field, Field, States, Limit_check@1, Widget} | Next_items] = case Items of
            [{list_field, _, _, _, _} | _] -> Items;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                            value => _assert_fail,
                            module => <<"formz"/utf8>>,
                            function => <<"limited_list"/utf8>>,
                            line => 558})
        end,
        Item_results = begin
            _pipe@1 = States,
            _pipe@2 = gleam@list:map(
                _pipe@1,
                fun(_capture) ->
                    parse_list_state(
                        _capture,
                        erlang:element(3, Definition),
                        erlang:element(4, Definition)
                    )
                end
            ),
            mark_above_max_values_as_invalid(_pipe@2, Limit_check@1)
        end,
        Item_outputs = begin
            _pipe@3 = Item_results,
            _pipe@4 = outputs_for_required_or_nonempty(_pipe@3),
            gleam@result:all(_pipe@4)
        end,
        Next_form@1 = Next(
            begin
                _pipe@5 = Item_outputs,
                gleam@result:unwrap(_pipe@5, [erlang:element(4, Definition)])
            end
        ),
        Form_output = (erlang:element(3, Next_form@1))(Next_items),
        case {Form_output, Item_outputs} of
            {{ok, _}, {ok, _}} ->
                Form_output;

            {{error, Error_items}, {ok, _}} ->
                States@1 = begin
                    _pipe@6 = States,
                    gleam@list:map(
                        _pipe@6,
                        fun(S) ->
                            {valid, erlang:element(2, S), erlang:element(3, S)}
                        end
                    )
                end,
                F = {list_field, Field, States@1, Limit_check@1, Widget},
                {error, [F | Error_items]};

            {{ok, _}, {error, _}} ->
                States@2 = gleam@list:map(
                    Item_results,
                    fun state_from_parse_result/1
                ),
                F@1 = {list_field, Field, States@2, Limit_check@1, Widget},
                {error, [F@1 | mark_all_fields_as_valid(Next_items)]};

            {{error, Error_items@1}, {error, _}} ->
                States@3 = gleam@list:map(
                    Item_results,
                    fun state_from_parse_result/1
                ),
                F@2 = {list_field, Field, States@3, Limit_check@1, Widget},
                {error, [F@2 | Error_items@1]}
        end
    end,
    {form, Updated_items, Decode, erlang:element(4, Next_form)}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 700).
-spec list(
    config(),
    definition(GBB, GBC, any()),
    fun((list(GBC)) -> form(GBB, GBI))
) -> form(GBB, GBI).
list(Config, Definition, Next) ->
    limited_list(limit_at_most(1000000), Config, Definition, Next).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 461).
-spec simple_limit_check(integer(), integer(), integer()) -> fun((integer()) -> {ok,
        list(input_state())} |
    {error, integer()}).
simple_limit_check(Min, Max, Extra) ->
    fun(Num_nonempty) -> case Max - Num_nonempty of
            X when X < 0 ->
                {error, - X};

            _ ->
                gleam@int:max(
                    1 - Num_nonempty,
                    gleam@int:min(Extra, Max - Num_nonempty)
                ),
                gleam@list:fold([1, Extra, Min], 0, fun gleam@int:max/2),
                Num_required = gleam@int:max(Min - Num_nonempty, 0),
                Num_base = case {Num_nonempty, Num_required} of
                    {X@1, Y} when (X@1 > 0) orelse (Y > 0) ->
                        0;

                    {_, _} ->
                        1
                end,
                Num_extra = gleam@int:min(Extra, Max - Num_nonempty),
                Num_optional = gleam@int:max(Num_base, Num_extra) - Num_required,
                {ok,
                    lists:append(
                        gleam@list:repeat(
                            {unvalidated, <<""/utf8>>, required},
                            Num_required
                        ),
                        gleam@list:repeat(
                            {unvalidated, <<""/utf8>>, optional},
                            Num_optional
                        )
                    )}
        end end.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 498).
-spec limit_at_least(integer()) -> fun((integer()) -> {ok, list(input_state())} |
    {error, integer()}).
limit_at_least(Min) ->
    simple_limit_check(Min, 1000000, 1).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 504).
-spec limit_at_most(integer()) -> fun((integer()) -> {ok, list(input_state())} |
    {error, integer()}).
limit_at_most(Max) ->
    simple_limit_check(0, Max, 1).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 510).
-spec limit_between(integer(), integer()) -> fun((integer()) -> {ok,
        list(input_state())} |
    {error, integer()}).
limit_between(Min, Max) ->
    simple_limit_check(Min, Max, 1).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 628).
-spec outputs_for_required_or_nonempty(list(list_parsing_result(GAM))) -> list({ok,
        GAM} |
    {error, binary()}).
outputs_for_required_or_nonempty(States) ->
    gleam@list:filter_map(
        States,
        fun(Result) ->
            case {erlang:element(2, Result), erlang:element(3, Result)} of
                {<<""/utf8>>, optional} ->
                    {error, nil};

                {_, _} ->
                    {ok, erlang:element(4, Result)}
            end
        end
    ).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 807).
-spec do_data(list(item(GCG)), gleam@dict:dict(binary(), list(binary()))) -> list(item(GCG)).
do_data(Items, Data) ->
    gleam@list:map(
        Items,
        fun(Item) ->
            Values = gleam@dict:get(
                Data,
                erlang:element(2, erlang:element(2, Item))
            ),
            case {Item, Values} of
                {{field, Detail, State, Widget}, {ok, [_ | _] = Values@1}} ->
                    _assert_subject = gleam@list:last(Values@1),
                    {ok, Last} = case _assert_subject of
                        {ok, _} -> _assert_subject;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        value => _assert_fail,
                                        module => <<"formz"/utf8>>,
                                        function => <<"do_data"/utf8>>,
                                        line => 815})
                    end,
                    {field,
                        Detail,
                        {unvalidated, Last, erlang:element(3, State)},
                        Widget};

                {{list_field, Detail@1, States, Limit_check, Widget@1},
                    {ok, Values@2}} ->
                    Nonempty = gleam@list:filter(
                        Values@2,
                        fun(V) -> not gleam@string:is_empty(V) end
                    ),
                    Num_nonempty = erlang:length(Nonempty),
                    Additional_fields = begin
                        _pipe = Limit_check(Num_nonempty),
                        gleam@result:unwrap(_pipe, [])
                    end,
                    Items@1 = begin
                        _pipe@1 = gleam@list:map2(
                            States,
                            Nonempty,
                            fun(S, V@1) ->
                                {unvalidated, V@1, erlang:element(3, S)}
                            end
                        ),
                        _pipe@4 = lists:append(
                            _pipe@1,
                            begin
                                _pipe@2 = Nonempty,
                                _pipe@3 = gleam@list:drop(
                                    _pipe@2,
                                    erlang:length(States)
                                ),
                                gleam@list:map(
                                    _pipe@3,
                                    fun(V@2) -> {unvalidated, V@2, optional} end
                                )
                            end
                        ),
                        lists:append(_pipe@4, Additional_fields)
                    end,
                    {list_field, Detail@1, Items@1, Limit_check, Widget@1};

                {{sub_form, Detail@2, Items@2}, _} ->
                    {sub_form, Detail@2, do_data(Items@2, Data)};

                {_, _} ->
                    Item
            end
        end
    ).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 840).
-spec to_dict(list({binary(), binary()})) -> gleam@dict:dict(binary(), list(binary())).
to_dict(Values) ->
    gleam@list:fold_right(
        Values,
        gleam@dict:new(),
        fun(Acc, Kv) ->
            {Key, Value} = Kv,
            gleam@dict:upsert(Acc, Key, fun(Opt) -> case Opt of
                        none ->
                            [Value];

                        {some, Values@1} ->
                            [Value | Values@1]
                    end end)
        end
    ).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 798).
-spec data(form(GBZ, GCA), list({binary(), binary()})) -> form(GBZ, GCA).
data(Form, Input_data) ->
    Data = to_dict(Input_data),
    {form, Items, Decode, Stub} = Form,
    {form, do_data(Items, Data), Decode, Stub}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 906).
-spec mark_all_fields_as_valid(list(item(GDP))) -> list(item(GDP)).
mark_all_fields_as_valid(Items) ->
    gleam@list:map(Items, fun(Item) -> case Item of
                {field, Field, State, Widget} ->
                    {field,
                        Field,
                        {valid,
                            erlang:element(2, State),
                            erlang:element(3, State)},
                        Widget};

                {list_field, Field@1, States, Limit_check, Widget@1} ->
                    New_states = begin
                        _pipe = States,
                        gleam@list:map(
                            _pipe,
                            fun(State@1) ->
                                {valid,
                                    erlang:element(2, State@1),
                                    erlang:element(3, State@1)}
                            end
                        )
                    end,
                    {list_field, Field@1, New_states, Limit_check, Widget@1};

                {sub_form, Subform, Items@1} ->
                    {sub_form, Subform, mark_all_fields_as_valid(Items@1)}
            end end).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 387).
-spec add_field(
    config(),
    requirement(),
    FZM,
    fun((binary()) -> {ok, FZN} | {error, binary()}),
    FZN,
    fun((FZN) -> form(FZM, FZQ))
) -> form(FZM, FZQ).
add_field(Config, Requirement, Widget, Parse_field, Stub, Next) ->
    Next_form = Next(Stub),
    Updated_items = [{field,
            Config,
            {unvalidated, <<""/utf8>>, Requirement},
            Widget} |
        erlang:element(2, Next_form)],
    Decode = fun(Items) ->
        [{field, Field, State, Widget@1} | Next_items] = case Items of
            [{field, _, _, _} | _] -> Items;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                            value => _assert_fail,
                            module => <<"formz"/utf8>>,
                            function => <<"add_field"/utf8>>,
                            line => 411})
        end,
        Item_output = Parse_field(erlang:element(2, State)),
        Next_form@1 = Next(
            begin
                _pipe = Item_output,
                gleam@result:unwrap(_pipe, Stub)
            end
        ),
        Form_output = (erlang:element(3, Next_form@1))(Next_items),
        case {Form_output, Item_output} of
            {{ok, _}, {ok, _}} ->
                Form_output;

            {{error, Error_items}, {ok, _}} ->
                F = {field,
                    Field,
                    {valid, erlang:element(2, State), Requirement},
                    Widget@1},
                {error, [F | Error_items]};

            {{ok, _}, {error, Error}} ->
                F@1 = {field,
                    Field,
                    {invalid, erlang:element(2, State), Requirement, Error},
                    Widget@1},
                {error, [F@1 | mark_all_fields_as_valid(Next_items)]};

            {{error, Error_items@1}, {error, Error@1}} ->
                F@2 = {field,
                    Field,
                    {invalid, erlang:element(2, State), Requirement, Error@1},
                    Widget@1},
                {error, [F@2 | Error_items@1]}
        end
    end,
    {form, Updated_items, Decode, erlang:element(4, Next_form)}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 342).
-spec field(config(), definition(FYQ, any(), FYS), fun((FYS) -> form(FYQ, FYW))) -> form(FYQ, FYW).
field(Config, Definition, Next) ->
    add_field(
        Config,
        optional,
        erlang:element(2, Definition),
        fun(_capture) ->
            (erlang:element(5, Definition))(
                erlang:element(3, Definition),
                _capture
            )
        end,
        erlang:element(6, Definition),
        Next
    ).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 372).
-spec required_field(
    config(),
    definition(FZB, FZC, any()),
    fun((FZC) -> form(FZB, FZH))
) -> form(FZB, FZH).
required_field(Config, Definition, Next) ->
    add_field(
        Config,
        required,
        erlang:element(2, Definition),
        erlang:element(3, Definition),
        erlang:element(4, Definition),
        Next
    ).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 737).
-spec subform(config(), form(GBQ, GBR), fun((GBR) -> form(GBQ, GBU))) -> form(GBQ, GBU).
subform(Config, Form, Next) ->
    Next_form = Next(erlang:element(4, Form)),
    Sub_items = begin
        _pipe = erlang:element(2, Form),
        gleam@list:map(
            _pipe,
            fun(_capture) ->
                add_prefix_to_item(_capture, erlang:element(2, Config))
            end
        )
    end,
    Subform = {sub_form, Config, Sub_items},
    Updated_items = [Subform | erlang:element(2, Next_form)],
    Decode = fun(Items) ->
        [{sub_form, Details, Sub_items@1} | Next_items] = case Items of
            [{sub_form, _, _} | _] -> Items;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                            value => _assert_fail,
                            module => <<"formz"/utf8>>,
                            function => <<"subform"/utf8>>,
                            line => 750})
        end,
        Item_output = (erlang:element(3, Form))(Sub_items@1),
        Next_form@1 = Next(
            begin
                _pipe@1 = Item_output,
                gleam@result:unwrap(_pipe@1, erlang:element(4, Form))
            end
        ),
        Form_output = (erlang:element(3, Next_form@1))(Next_items),
        case {Form_output, Item_output} of
            {{ok, _}, {ok, _}} ->
                Form_output;

            {{error, Next_error_items}, {ok, _}} ->
                Sub = {sub_form,
                    Details,
                    begin
                        _pipe@2 = Sub_items@1,
                        mark_all_fields_as_valid(_pipe@2)
                    end},
                {error, [Sub | Next_error_items]};

            {{ok, _}, {error, Error_items}} ->
                Sub@1 = {sub_form, Details, Error_items},
                {error, [Sub@1 | mark_all_fields_as_valid(Next_items)]};

            {{error, Next_error_items@1}, {error, Error_items@1}} ->
                Sub@2 = {sub_form, Details, Error_items@1},
                {error, [Sub@2 | Next_error_items@1]}
        end
    end,
    {form, Updated_items, Decode, erlang:element(4, Next_form)}.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 894).
-spec decode_then_try(
    form(GDA, GDB),
    fun((form(GDA, GDB), GDB) -> {ok, GDG} | {error, form(GDA, GDB)})
) -> {ok, GDG} | {error, form(GDA, GDB)}.
decode_then_try(Form, Fun) ->
    _pipe = Form,
    _pipe@1 = decode(_pipe),
    gleam@result:'try'(
        _pipe@1,
        fun(Output) ->
            Items = begin
                _pipe@2 = erlang:element(2, Form),
                mark_all_fields_as_valid(_pipe@2)
            end,
            Fun(erlang:setelement(2, Form, Items), Output)
        end
    ).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 986).
-spec get(form(GEN, any()), binary()) -> {ok, item(GEN)} | {error, nil}.
get(Form, Name) ->
    gleam@list:find(
        erlang:element(2, Form),
        fun(Item) -> Name =:= get_item_name(Item) end
    ).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 928).
-spec validate(form(GDU, GDV), list(binary())) -> form(GDU, GDV).
validate(Form, Names) ->
    case (erlang:element(3, Form))(erlang:element(2, Form)) of
        {ok, _} ->
            Items = gleam@list:map(
                erlang:element(2, Form),
                fun(Parsed_item) ->
                    Item_name = get_item_name(Parsed_item),
                    case gleam@list:find(
                        Names,
                        fun(Name) -> Item_name =:= Name end
                    ) of
                        {ok, _} ->
                            _assert_subject = begin
                                _pipe = [Parsed_item],
                                _pipe@1 = mark_all_fields_as_valid(_pipe),
                                gleam@list:first(_pipe@1)
                            end,
                            {ok, Item} = case _assert_subject of
                                {ok, _} -> _assert_subject;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                value => _assert_fail,
                                                module => <<"formz"/utf8>>,
                                                function => <<"validate"/utf8>>,
                                                line => 939})
                            end,
                            Item;

                        {error, _} ->
                            _assert_subject@1 = get(Form, Item_name),
                            {ok, Original_item} = case _assert_subject@1 of
                                {ok, _} -> _assert_subject@1;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                value => _assert_fail@1,
                                                module => <<"formz"/utf8>>,
                                                function => <<"validate"/utf8>>,
                                                line => 944})
                            end,
                            Original_item
                    end
                end
            ),
            erlang:setelement(2, Form, Items);

        {error, Items@1} ->
            Items@2 = gleam@list:map(
                Items@1,
                fun(Parsed_item@1) ->
                    Item_name@1 = get_item_name(Parsed_item@1),
                    case gleam@list:find(
                        Names,
                        fun(Name@1) -> Item_name@1 =:= Name@1 end
                    ) of
                        {ok, _} ->
                            Parsed_item@1;

                        {error, _} ->
                            _assert_subject@2 = get(Form, Item_name@1),
                            {ok, Original_item@1} = case _assert_subject@2 of
                                {ok, _} -> _assert_subject@2;
                                _assert_fail@2 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                value => _assert_fail@2,
                                                module => <<"formz"/utf8>>,
                                                function => <<"validate"/utf8>>,
                                                line => 958})
                            end,
                            Original_item@1
                    end
                end
            ),
            erlang:setelement(2, Form, Items@2)
    end.

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 972).
-spec validate_all(form(GEB, GEC)) -> form(GEB, GEC).
validate_all(Form) ->
    _pipe = erlang:element(2, Form),
    _pipe@1 = gleam@list:map(_pipe, fun get_item_name/1),
    validate(Form, _pipe@1).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1005).
-spec do_update(list(item(GFB)), binary(), fun((item(GFB)) -> item(GFB))) -> list(item(GFB)).
do_update(Items, Name, Fun) ->
    gleam@list:map(Items, fun(Item) -> case Item of
                {field, Detail, _, _} when erlang:element(2, Detail) =:= Name ->
                    Fun(Item);

                {list_field, Detail@1, _, _, _} when erlang:element(2, Detail@1) =:= Name ->
                    Fun(Item);

                {sub_form, Detail@2, Items@1} ->
                    Sub = {sub_form, Detail@2, do_update(Items@1, Name, Fun)},
                    case erlang:element(2, Detail@2) =:= Name of
                        true ->
                            Fun(Sub);

                        false ->
                            Sub
                    end;

                _ ->
                    Item
            end end).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 996).
-spec update(form(GEU, GEV), binary(), fun((item(GEU)) -> item(GEU))) -> form(GEU, GEV).
update(Form, Name, Fun) ->
    Items = do_update(erlang:element(2, Form), Name, Fun),
    erlang:setelement(2, Form, Items).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1036).
-spec update_config(form(GFI, GFJ), binary(), fun((config()) -> config())) -> form(GFI, GFJ).
update_config(Form, Name, Fun) ->
    update(Form, Name, fun(Item) -> case Item of
                {field, Details, _, _} ->
                    erlang:setelement(2, Item, Fun(Details));

                {list_field, Details@1, _, _, _} ->
                    erlang:setelement(2, Item, Fun(Details@1));

                {sub_form, Details@2, _} ->
                    erlang:setelement(2, Item, Fun(Details@2))
            end end).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1058).
-spec field_error(form(GFO, GFP), binary(), binary()) -> form(GFO, GFP).
field_error(Form, Name, Str) ->
    update(Form, Name, fun(Item) -> case Item of
                {field, Field, State, Widget} ->
                    {field,
                        Field,
                        {invalid,
                            erlang:element(2, State),
                            erlang:element(3, State),
                            Str},
                        Widget};

                _ ->
                    Item
            end end).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1085).
-spec listfield_errors(
    form(GFU, GFV),
    binary(),
    list({ok, nil} | {error, binary()})
) -> form(GFU, GFV).
listfield_errors(Form, Name, Errors) ->
    update(Form, Name, fun(Item) -> case Item of
                {list_field, Field, States, Limit_check, Widget} ->
                    Invalid_states = gleam@list:map2(
                        States,
                        Errors,
                        fun(State, Err) -> case Err of
                                {error, Str} ->
                                    {invalid,
                                        erlang:element(2, State),
                                        erlang:element(3, State),
                                        Str};

                                {ok, nil} ->
                                    State
                            end end
                    ),
                    {list_field, Field, Invalid_states, Limit_check, Widget};

                _ ->
                    Item
            end end).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1248).
-spec do_get_states(list(item(any()))) -> list(input_state()).
do_get_states(Items) ->
    gleam@list:fold(Items, [], fun(Acc, Item) -> case Item of
                {field, _, State, _} ->
                    [State | Acc];

                {list_field, _, States, _, _} ->
                    lists:append(
                        begin
                            _pipe = States,
                            lists:reverse(_pipe)
                        end,
                        Acc
                    );

                {sub_form, _, Sub_items} ->
                    gleam@list:flatten([do_get_states(Sub_items), Acc])
            end end).

-file("/Users/benjamin/Projects/formz/formz/src/formz.gleam", 1244).
-spec get_states(form(any(), any())) -> list(input_state()).
get_states(Form) ->
    _pipe = erlang:element(2, Form),
    _pipe@1 = do_get_states(_pipe),
    lists:reverse(_pipe@1).