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

-export([int_min_with_message/3, int_max_with_message/3, dynamic/1, string_enum_with_message/3, string_enum/2, element_with_message/3, decode1/2, decode2/3, decode3/4, decode4/5, decode5/6, decode6/7, decode7/8, decode8/9, decode9/10, replace/2, map/2, dict/2, bool_with_message/1, bool/1, int_with_message/1, int/1, int_min/2, int_max/2, string_with_message/1, string/1, string_len_with_message/3, string_len/2, string_min_len_with_message/3, string_min_len/2, string_max_len_with_message/3, string_max_len/2, field/2, element/2, bool_literal_with_message/2, bool_literal/1, int_literal_with_message/2, int_literal/1, string_literal_with_message/2, string_literal/1]).
-export_type([decode_error_kind/0, decode_error/0, unknown_tuple/0]).

-type decode_error_kind() :: {type_mismatch, binary(), binary()} |
    {int_min_error, integer(), integer()} |
    {int_max_error, integer(), integer()} |
    field_not_found |
    {not_in_string_enum, list(binary()), binary()} |
    {string_len_error, integer(), integer()} |
    {string_min_len_error, integer(), integer()} |
    {string_max_len_error, integer(), integer()} |
    {tuple_negative_index, integer()} |
    {tuple_too_small, integer(), integer()}.

-type decode_error() :: {decode_error,
        binary(),
        list(binary()),
        decode_error_kind()}.

-type unknown_tuple() :: any().

-spec int_min_with_message(
    fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
        {error, list(decode_error())}),
    integer(),
    binary()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
    {error, list(decode_error())}).
int_min_with_message(Source, Min, Message) ->
    fun(Data) ->
        gleam@result:'try'(Source(Data), fun(Decoded) -> case Decoded >= Min of
                    true ->
                        {ok, Decoded};

                    false ->
                        {error,
                            [{decode_error,
                                    Message,
                                    [],
                                    {int_min_error, Min, Decoded}}]}
                end end)
    end.

-spec int_max_with_message(
    fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
        {error, list(decode_error())}),
    integer(),
    binary()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
    {error, list(decode_error())}).
int_max_with_message(Source, Max, Message) ->
    fun(Data) ->
        gleam@result:'try'(Source(Data), fun(Decoded) -> case Decoded =< Max of
                    true ->
                        {ok, Decoded};

                    false ->
                        {error,
                            [{decode_error,
                                    Message,
                                    [],
                                    {int_max_error, Max, Decoded}}]}
                end end)
    end.

-spec dynamic(gleam@dynamic:dynamic_()) -> {ok, gleam@dynamic:dynamic_()} |
    {error, list(decode_error())}.
dynamic(Value) ->
    {ok, Value}.

-spec string_enum_with_message(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    list({binary(), FLQ}),
    binary()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FLQ} | {error, list(decode_error())}).
string_enum_with_message(Source, Definition, Message) ->
    fun(Data) ->
        gleam@result:'try'(
            Source(Data),
            fun(Source_value) ->
                Maybe_enum_value = begin
                    _pipe = Definition,
                    gleam@list:key_find(_pipe, Source_value)
                end,
                case Maybe_enum_value of
                    {ok, Enum_value} ->
                        {ok, Enum_value};

                    {error, _} ->
                        Available_keys = gleam@list:map(
                            Definition,
                            fun(Definition_pair) ->
                                erlang:element(1, Definition_pair)
                            end
                        ),
                        {error,
                            [{decode_error,
                                    Message,
                                    [],
                                    {not_in_string_enum,
                                        Available_keys,
                                        Source_value}}]}
                end
            end
        )
    end.

-spec string_enum(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    list({binary(), FLU})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FLU} | {error, list(decode_error())}).
string_enum(Source, Definition) ->
    string_enum_with_message(
        Source,
        Definition,
        <<"Expected String enum"/utf8>>
    ).

-spec element_with_message(
    integer(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FLX} | {error, list(decode_error())}),
    binary()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FLX} | {error, list(decode_error())}).
element_with_message(Index, Inner_decoder, Message) ->
    fun(Data) -> gleam@result:'try'(case Index < 0 of
                true ->
                    {error,
                        [{decode_error,
                                Message,
                                [],
                                {tuple_negative_index, Index}}]};

                false ->
                    {ok, nil}
            end, fun(_) ->
                gleam@result:'try'(
                    begin
                        _pipe = gleam_stdlib:decode_tuple(Data),
                        gleam@result:replace_error(
                            _pipe,
                            [{decode_error,
                                    Message,
                                    [],
                                    {type_mismatch,
                                        <<"Tuple"/utf8>>,
                                        gleam@dynamic:classify(Data)}}]
                        )
                    end,
                    fun(Tuple) ->
                        gleam@result:'try'(
                            begin
                                _pipe@1 = gleam_stdlib:tuple_get(Tuple, Index),
                                gleam@result:replace_error(
                                    _pipe@1,
                                    [{decode_error,
                                            Message,
                                            [],
                                            {tuple_too_small,
                                                Index + 1,
                                                gleam_stdlib:size_of_tuple(
                                                    Tuple
                                                )}}]
                                )
                            end,
                            fun(Element) -> Inner_decoder(Element) end
                        )
                    end
                )
            end) end.

-spec all_errors({ok, any()} | {error, list(decode_error())}) -> list(decode_error()).
all_errors(Result) ->
    case Result of
        {ok, _} ->
            [];

        {error, Errors} ->
            Errors
    end.

-spec decode1(
    fun((FMH) -> FMI),
    fun((gleam@dynamic:dynamic_()) -> {ok, FMH} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FMI} | {error, list(decode_error())}).
decode1(Constructor, T1) ->
    fun(Value) -> case T1(Value) of
            {ok, A} ->
                {ok, Constructor(A)};

            A@1 ->
                {error, all_errors(A@1)}
        end end.

-spec decode2(
    fun((FML, FMM) -> FMN),
    fun((gleam@dynamic:dynamic_()) -> {ok, FML} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FMM} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FMN} | {error, list(decode_error())}).
decode2(Constructor, T1, T2) ->
    fun(Value) -> case {T1(Value), T2(Value)} of
            {{ok, A}, {ok, B}} ->
                {ok, Constructor(A, B)};

            {A@1, B@1} ->
                {error, gleam@list:concat([all_errors(A@1), all_errors(B@1)])}
        end end.

-spec decode3(
    fun((FMR, FMS, FMT) -> FMU),
    fun((gleam@dynamic:dynamic_()) -> {ok, FMR} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FMS} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FMT} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FMU} | {error, list(decode_error())}).
decode3(Constructor, T1, T2, T3) ->
    fun(Value) -> case {T1(Value), T2(Value), T3(Value)} of
            {{ok, A}, {ok, B}, {ok, C}} ->
                {ok, Constructor(A, B, C)};

            {A@1, B@1, C@1} ->
                {error,
                    gleam@list:concat(
                        [all_errors(A@1), all_errors(B@1), all_errors(C@1)]
                    )}
        end end.

-spec decode4(
    fun((FMZ, FNA, FNB, FNC) -> FND),
    fun((gleam@dynamic:dynamic_()) -> {ok, FMZ} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNA} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNB} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNC} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FND} | {error, list(decode_error())}).
decode4(Constructor, T1, T2, T3, T4) ->
    fun(Data) -> case {T1(Data), T2(Data), T3(Data), T4(Data)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}} ->
                {ok, Constructor(A, B, C, D)};

            {A@1, B@1, C@1, D@1} ->
                {error,
                    gleam@list:concat(
                        [all_errors(A@1),
                            all_errors(B@1),
                            all_errors(C@1),
                            all_errors(D@1)]
                    )}
        end end.

-spec decode5(
    fun((FNJ, FNK, FNL, FNM, FNN) -> FNO),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNJ} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNK} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNL} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNM} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNN} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FNO} | {error, list(decode_error())}).
decode5(Constructor, T1, T2, T3, T4, T5) ->
    fun(Data) -> case {T1(Data), T2(Data), T3(Data), T4(Data), T5(Data)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}, {ok, E}} ->
                {ok, Constructor(A, B, C, D, E)};

            {A@1, B@1, C@1, D@1, E@1} ->
                {error,
                    gleam@list:concat(
                        [all_errors(A@1),
                            all_errors(B@1),
                            all_errors(C@1),
                            all_errors(D@1),
                            all_errors(E@1)]
                    )}
        end end.

-spec decode6(
    fun((FNV, FNW, FNX, FNY, FNZ, FOA) -> FOB),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNV} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNW} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNX} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNY} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FNZ} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOA} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FOB} | {error, list(decode_error())}).
decode6(Constructor, T1, T2, T3, T4, T5, T6) ->
    fun(Data) ->
        case {T1(Data), T2(Data), T3(Data), T4(Data), T5(Data), T6(Data)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}, {ok, E}, {ok, F}} ->
                {ok, Constructor(A, B, C, D, E, F)};

            {A@1, B@1, C@1, D@1, E@1, F@1} ->
                {error,
                    gleam@list:concat(
                        [all_errors(A@1),
                            all_errors(B@1),
                            all_errors(C@1),
                            all_errors(D@1),
                            all_errors(E@1),
                            all_errors(F@1)]
                    )}
        end
    end.

-spec decode7(
    fun((FOJ, FOK, FOL, FOM, FON, FOO, FOP) -> FOQ),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOJ} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOK} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOL} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOM} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FON} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOO} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOP} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FOQ} | {error, list(decode_error())}).
decode7(Constructor, T1, T2, T3, T4, T5, T6, T7) ->
    fun(Data) ->
        case {T1(Data),
            T2(Data),
            T3(Data),
            T4(Data),
            T5(Data),
            T6(Data),
            T7(Data)} of
            {{ok, A}, {ok, B}, {ok, C}, {ok, D}, {ok, E}, {ok, F}, {ok, G}} ->
                {ok, Constructor(A, B, C, D, E, F, G)};

            {A@1, B@1, C@1, D@1, E@1, F@1, G@1} ->
                {error,
                    gleam@list:concat(
                        [all_errors(A@1),
                            all_errors(B@1),
                            all_errors(C@1),
                            all_errors(D@1),
                            all_errors(E@1),
                            all_errors(F@1),
                            all_errors(G@1)]
                    )}
        end
    end.

-spec decode8(
    fun((FOZ, FPA, FPB, FPC, FPD, FPE, FPF, FPG) -> FPH),
    fun((gleam@dynamic:dynamic_()) -> {ok, FOZ} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPA} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPB} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPC} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPD} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPE} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPF} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPG} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FPH} | {error, list(decode_error())}).
decode8(Constructor, T1, T2, T3, T4, T5, T6, T7, T8) ->
    fun(Data) ->
        case {T1(Data),
            T2(Data),
            T3(Data),
            T4(Data),
            T5(Data),
            T6(Data),
            T7(Data),
            T8(Data)} of
            {{ok, A},
                {ok, B},
                {ok, C},
                {ok, D},
                {ok, E},
                {ok, F},
                {ok, G},
                {ok, H}} ->
                {ok, Constructor(A, B, C, D, E, F, G, H)};

            {A@1, B@1, C@1, D@1, E@1, F@1, G@1, H@1} ->
                {error,
                    gleam@list:concat(
                        [all_errors(A@1),
                            all_errors(B@1),
                            all_errors(C@1),
                            all_errors(D@1),
                            all_errors(E@1),
                            all_errors(F@1),
                            all_errors(G@1),
                            all_errors(H@1)]
                    )}
        end
    end.

-spec decode9(
    fun((FPR, FPS, FPT, FPU, FPV, FPW, FPX, FPY, FPZ) -> FQA),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPR} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPS} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPT} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPU} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPV} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPW} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPX} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPY} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FPZ} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FQA} | {error, list(decode_error())}).
decode9(Constructor, T1, T2, T3, T4, T5, T6, T7, T8, T9) ->
    fun(Data) ->
        case {T1(Data),
            T2(Data),
            T3(Data),
            T4(Data),
            T5(Data),
            T6(Data),
            T7(Data),
            T8(Data),
            T9(Data)} of
            {{ok, A},
                {ok, B},
                {ok, C},
                {ok, D},
                {ok, E},
                {ok, F},
                {ok, G},
                {ok, H},
                {ok, I}} ->
                {ok, Constructor(A, B, C, D, E, F, G, H, I)};

            {A@1, B@1, C@1, D@1, E@1, F@1, G@1, H@1, I@1} ->
                {error,
                    gleam@list:concat(
                        [all_errors(A@1),
                            all_errors(B@1),
                            all_errors(C@1),
                            all_errors(D@1),
                            all_errors(E@1),
                            all_errors(F@1),
                            all_errors(G@1),
                            all_errors(H@1),
                            all_errors(I@1)]
                    )}
        end
    end.

-spec replace(
    fun((gleam@dynamic:dynamic_()) -> {ok, any()} |
        {error, list(decode_error())}),
    FQS
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FQS} | {error, list(decode_error())}).
replace(Source, Replace_value) ->
    fun(Data) -> gleam@result:map(Source(Data), fun(_) -> Replace_value end) end.

-spec map(
    fun((gleam@dynamic:dynamic_()) -> {ok, FQU} | {error, list(decode_error())}),
    fun((FQU) -> FQW)
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FQW} | {error, list(decode_error())}).
map(Source, Mapper) ->
    fun(Data) ->
        gleam@result:map(
            Source(Data),
            fun(Decoded_data) -> Mapper(Decoded_data) end
        )
    end.

-spec map_errors(
    {ok, FQY} | {error, list(decode_error())},
    fun((decode_error()) -> decode_error())
) -> {ok, FQY} | {error, list(decode_error())}.
map_errors(Result, Mapper) ->
    _pipe = Result,
    gleam@result:map_error(_pipe, fun(Errors) -> _pipe@1 = Errors,
            gleam@list:map(_pipe@1, Mapper) end).

-spec push_path(decode_error(), binary()) -> decode_error().
push_path(Error, Path_segment) ->
    erlang:setelement(3, Error, [Path_segment | erlang:element(3, Error)]).

-spec dict(
    fun((gleam@dynamic:dynamic_()) -> {ok, FLE} | {error, list(decode_error())}),
    fun((gleam@dynamic:dynamic_()) -> {ok, FLG} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, gleam@dict:dict(FLE, FLG)} |
    {error, list(decode_error())}).
dict(Key_decoder, Value_decoder) ->
    fun(Data) ->
        gleam@result:'try'(
            begin
                _pipe = (gleam@dynamic:dict(
                    fun gleam@dynamic:dynamic/1,
                    fun gleam@dynamic:dynamic/1
                ))(Data),
                gleam@result:replace_error(
                    _pipe,
                    [{decode_error,
                            <<"Expected type Dict"/utf8>>,
                            [],
                            {type_mismatch,
                                <<"Dict"/utf8>>,
                                gleam@dynamic:classify(Data)}}]
                )
            end,
            fun(Decoded) ->
                gleam@result:'try'(
                    begin
                        _pipe@1 = Decoded,
                        _pipe@2 = maps:to_list(_pipe@1),
                        gleam@list:try_map(
                            _pipe@2,
                            fun(Pair) ->
                                {Key, Value} = Pair,
                                gleam@result:'try'(
                                    begin
                                        _pipe@3 = Key_decoder(Key),
                                        map_errors(
                                            _pipe@3,
                                            fun(_capture) ->
                                                push_path(
                                                    _capture,
                                                    <<"[key]"/utf8>>
                                                )
                                            end
                                        )
                                    end,
                                    fun(Decoded_key) ->
                                        gleam@result:'try'(
                                            begin
                                                _pipe@4 = Value_decoder(Value),
                                                map_errors(
                                                    _pipe@4,
                                                    fun(_capture@1) ->
                                                        push_path(
                                                            _capture@1,
                                                            <<"[value]"/utf8>>
                                                        )
                                                    end
                                                )
                                            end,
                                            fun(Decoded_value) ->
                                                {ok,
                                                    {Decoded_key, Decoded_value}}
                                            end
                                        )
                                    end
                                )
                            end
                        )
                    end,
                    fun(Pairs) -> {ok, maps:from_list(Pairs)} end
                )
            end
        )
    end.

-spec create_basic_decoder(
    binary(),
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FRB} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FRB} | {error, list(decode_error())}).
create_basic_decoder(Message, Expected, Decoder) ->
    fun(Data) -> case Decoder(Data) of
            {ok, Decoded_value} ->
                {ok, Decoded_value};

            {error, _} ->
                {error,
                    [{decode_error,
                            Message,
                            [],
                            {type_mismatch,
                                Expected,
                                gleam@dynamic:classify(Data)}}]}
        end end.

-spec bool_with_message(binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        boolean()} |
    {error, list(decode_error())}).
bool_with_message(Message) ->
    create_basic_decoder(Message, <<"Bool"/utf8>>, fun gleam@dynamic:bool/1).

-spec bool(gleam@dynamic:dynamic_()) -> {ok, boolean()} |
    {error, list(decode_error())}.
bool(Data) ->
    (bool_with_message(<<"Expected type Bool"/utf8>>))(Data).

-spec int_with_message(binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        integer()} |
    {error, list(decode_error())}).
int_with_message(Message) ->
    create_basic_decoder(Message, <<"Int"/utf8>>, fun gleam@dynamic:int/1).

-spec int(gleam@dynamic:dynamic_()) -> {ok, integer()} |
    {error, list(decode_error())}.
int(Data) ->
    (int_with_message(<<"Expected type Int"/utf8>>))(Data).

-spec int_min(
    fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
        {error, list(decode_error())}),
    integer()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
    {error, list(decode_error())}).
int_min(Source, Min) ->
    int_min_with_message(
        Source,
        Min,
        <<"Int is too small. Min is "/utf8, (gleam@int:to_string(Min))/binary>>
    ).

-spec int_max(
    fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
        {error, list(decode_error())}),
    integer()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, integer()} |
    {error, list(decode_error())}).
int_max(Source, Max) ->
    int_max_with_message(
        Source,
        Max,
        <<"Int too large. Max is "/utf8, (gleam@int:to_string(Max))/binary>>
    ).

-spec string_with_message(binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        binary()} |
    {error, list(decode_error())}).
string_with_message(Message) ->
    create_basic_decoder(Message, <<"String"/utf8>>, fun gleam@dynamic:string/1).

-spec string(gleam@dynamic:dynamic_()) -> {ok, binary()} |
    {error, list(decode_error())}.
string(Data) ->
    (string_with_message(<<"Expected type String"/utf8>>))(Data).

-spec string_len_with_message(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    integer(),
    binary()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
    {error, list(decode_error())}).
string_len_with_message(Source, Len, Message) ->
    fun(Data) ->
        gleam@result:'try'(
            Source(Data),
            fun(Decoded_data) ->
                Actual_length = gleam@string:length(Decoded_data),
                Is_in_limit = Actual_length =:= Len,
                case Is_in_limit of
                    true ->
                        {ok, Decoded_data};

                    false ->
                        {error,
                            [{decode_error,
                                    Message,
                                    [],
                                    {string_len_error, Len, Actual_length}}]}
                end
            end
        )
    end.

-spec string_len(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    integer()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
    {error, list(decode_error())}).
string_len(Source, Len) ->
    string_len_with_message(
        Source,
        Len,
        <<"String has wrong length. Expected length is "/utf8,
            (gleam@int:to_string(Len))/binary>>
    ).

-spec string_min_len_with_message(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    integer(),
    binary()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
    {error, list(decode_error())}).
string_min_len_with_message(Source, Min_len, Message) ->
    fun(Data) ->
        gleam@result:'try'(
            Source(Data),
            fun(Decoded_data) ->
                Actual_length = gleam@string:length(Decoded_data),
                Is_in_limit = Actual_length >= Min_len,
                case Is_in_limit of
                    true ->
                        {ok, Decoded_data};

                    false ->
                        {error,
                            [{decode_error,
                                    Message,
                                    [],
                                    {string_min_len_error,
                                        Min_len,
                                        Actual_length}}]}
                end
            end
        )
    end.

-spec string_min_len(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    integer()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
    {error, list(decode_error())}).
string_min_len(Source, Min_len) ->
    string_min_len_with_message(
        Source,
        Min_len,
        <<"String is too short. Min length is "/utf8,
            (gleam@int:to_string(Min_len))/binary>>
    ).

-spec string_max_len_with_message(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    integer(),
    binary()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
    {error, list(decode_error())}).
string_max_len_with_message(Source, Max_len, Message) ->
    fun(Data) ->
        gleam@result:'try'(
            Source(Data),
            fun(Decoded_data) ->
                Actual_length = gleam@string:length(Decoded_data),
                Is_in_limit = Actual_length =< Max_len,
                case Is_in_limit of
                    true ->
                        {ok, Decoded_data};

                    false ->
                        {error,
                            [{decode_error,
                                    Message,
                                    [],
                                    {string_max_len_error,
                                        Max_len,
                                        Actual_length}}]}
                end
            end
        )
    end.

-spec string_max_len(
    fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
        {error, list(decode_error())}),
    integer()
) -> fun((gleam@dynamic:dynamic_()) -> {ok, binary()} |
    {error, list(decode_error())}).
string_max_len(Source, Max_len) ->
    string_max_len_with_message(
        Source,
        Max_len,
        <<"String is too long. Max length is "/utf8,
            (gleam@int:to_string(Max_len))/binary>>
    ).

-spec field(
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FLM} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FLM} | {error, list(decode_error())}).
field(Name, Inner_decoder) ->
    fun(Data) ->
        gleam@result:'try'(
            (dict(fun string/1, fun dynamic/1))(Data),
            fun(Map) ->
                Maybe_field_value = gleam@dict:get(Map, Name),
                case Maybe_field_value of
                    {ok, Field_value} ->
                        _pipe = Inner_decoder(Field_value),
                        map_errors(
                            _pipe,
                            fun(_capture) -> push_path(_capture, Name) end
                        );

                    {error, _} ->
                        {error,
                            [{decode_error,
                                    <<<<"Field '"/utf8, Name/binary>>/binary,
                                        "' not found"/utf8>>,
                                    [],
                                    field_not_found}]}
                end
            end
        )
    end.

-spec element(
    integer(),
    fun((gleam@dynamic:dynamic_()) -> {ok, FME} | {error, list(decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FME} | {error, list(decode_error())}).
element(Index, Inner_decoder) ->
    element_with_message(
        Index,
        Inner_decoder,
        <<"Expected tuple of size at least "/utf8,
            (gleam@int:to_string(Index + 1))/binary>>
    ).

-spec create_literal_decoder(
    binary(),
    FRE,
    fun((FRE) -> binary()),
    fun((gleam@dynamic:dynamic_()) -> {ok, FRE} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, FRE} | {error, list(decode_error())}).
create_literal_decoder(Message, Expected_value, Trust_type_constructor, Decoder) ->
    fun(Data) -> case Decoder(Data) of
            {ok, Decoded_value} when Decoded_value =:= Expected_value ->
                {ok, Decoded_value};

            {ok, Decoded_value@1} ->
                {error,
                    [{decode_error,
                            Message,
                            [],
                            {type_mismatch,
                                Trust_type_constructor(Expected_value),
                                Trust_type_constructor(Decoded_value@1)}}]};

            {error, _} ->
                {error,
                    [{decode_error,
                            Message,
                            [],
                            {type_mismatch,
                                Trust_type_constructor(Expected_value),
                                gleam@dynamic:classify(Data)}}]}
        end end.

-spec bool_literal_with_message(boolean(), binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        boolean()} |
    {error, list(decode_error())}).
bool_literal_with_message(Value, Message) ->
    create_literal_decoder(
        Message,
        Value,
        fun gleam@bool:to_string/1,
        fun gleam@dynamic:bool/1
    ).

-spec bool_literal(boolean()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        boolean()} |
    {error, list(decode_error())}).
bool_literal(Value) ->
    bool_literal_with_message(
        Value,
        <<"Expected "/utf8, (gleam@bool:to_string(Value))/binary>>
    ).

-spec int_literal_with_message(integer(), binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        integer()} |
    {error, list(decode_error())}).
int_literal_with_message(Value, Message) ->
    create_literal_decoder(
        Message,
        Value,
        fun gleam@int:to_string/1,
        fun gleam@dynamic:int/1
    ).

-spec int_literal(integer()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        integer()} |
    {error, list(decode_error())}).
int_literal(Value) ->
    int_literal_with_message(
        Value,
        <<"Expected "/utf8, (gleam@int:to_string(Value))/binary>>
    ).

-spec string_literal_with_message(binary(), binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        binary()} |
    {error, list(decode_error())}).
string_literal_with_message(Value, Message) ->
    create_literal_decoder(
        Message,
        Value,
        fun(V) -> <<<<"\""/utf8, V/binary>>/binary, "\""/utf8>> end,
        fun gleam@dynamic:string/1
    ).

-spec string_literal(binary()) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        binary()} |
    {error, list(decode_error())}).
string_literal(Value) ->
    string_literal_with_message(
        Value,
        <<<<"Expected \""/utf8, Value/binary>>/binary, "\""/utf8>>
    ).