-module(valkyrie@resp).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/valkyrie/resp.gleam").
-export([error_string/2, decode_value/1, encode_command/1]).
-export_type([value/0]).

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

-type value() :: nan |
    null |
    infinity |
    {integer, integer()} |
    {boolean, boolean()} |
    {double, float()} |
    {big_number, integer()} |
    negative_infinity |
    {push, list(value())} |
    {bulk_error, binary()} |
    {bulk_string, binary()} |
    {array, list(value())} |
    {set, gleam@set:set(value())} |
    {simple_error, binary()} |
    {integer_as_double, integer()} |
    {simple_string, binary()} |
    {map, gleam@dict:dict(value(), value())}.

-file("src/valkyrie/resp.gleam", 31).
-spec value_name(value()) -> binary().
value_name(Value) ->
    case Value of
        nan ->
            <<"Nan"/utf8>>;

        null ->
            <<"Null"/utf8>>;

        infinity ->
            <<"Infinity"/utf8>>;

        {integer, _} ->
            <<"Integer"/utf8>>;

        {boolean, _} ->
            <<"Boolean"/utf8>>;

        {double, _} ->
            <<"Double"/utf8>>;

        {big_number, _} ->
            <<"BigNumber"/utf8>>;

        negative_infinity ->
            <<"NegativeInfinity"/utf8>>;

        {push, _} ->
            <<"Push"/utf8>>;

        {bulk_error, _} ->
            <<"BulkError"/utf8>>;

        {bulk_string, _} ->
            <<"BulkString"/utf8>>;

        {array, _} ->
            <<"Array"/utf8>>;

        {set, _} ->
            <<"Set"/utf8>>;

        {simple_error, _} ->
            <<"SimpleError"/utf8>>;

        {integer_as_double, _} ->
            <<"IntegerAsDouble"/utf8>>;

        {simple_string, _} ->
            <<"SimpleString"/utf8>>;

        {map, _} ->
            <<"Map"/utf8>>
    end.

-file("src/valkyrie/resp.gleam", 53).
-spec values_to_names(list(value())) -> binary().
values_to_names(Values) ->
    case Values of
        [] ->
            <<"[]"/utf8>>;

        [Value] ->
            value_name(Value);

        Values@1 ->
            _pipe = Values@1,
            _pipe@1 = gleam@list:map(_pipe, fun value_name/1),
            gleam@string:join(_pipe@1, <<", "/utf8>>)
    end.

-file("src/valkyrie/resp.gleam", 65).
?DOC(false).
-spec error_string(binary(), list(value())) -> binary().
error_string(Expected, Got) ->
    <<<<<<"Expected "/utf8, Expected/binary>>/binary, ", got "/utf8>>/binary,
        (values_to_names(Got))/binary>>.

-file("src/valkyrie/resp.gleam", 102).
-spec null() -> binary().
null() ->
    <<"_\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 106).
-spec nan() -> binary().
nan() ->
    <<",nan\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 110).
-spec infinity() -> binary().
infinity() ->
    <<",inf\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 114).
-spec negative_infinity() -> binary().
negative_infinity() ->
    <<",-inf\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 118).
-spec integer(integer()) -> binary().
integer(Value) ->
    <<<<":"/utf8, (erlang:integer_to_binary(Value))/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 122).
-spec boolean(boolean()) -> binary().
boolean(Value) ->
    case Value of
        true ->
            <<"#t\r\n"/utf8>>;

        false ->
            <<"#f\r\n"/utf8>>
    end.

-file("src/valkyrie/resp.gleam", 129).
-spec simple_string(binary()) -> binary().
simple_string(Value) ->
    <<<<"+"/utf8,
            (begin
                _pipe = Value,
                _pipe@1 = gleam@string:replace(
                    _pipe,
                    <<"\r"/utf8>>,
                    <<""/utf8>>
                ),
                gleam@string:replace(_pipe@1, <<"\n"/utf8>>, <<""/utf8>>)
            end)/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 139).
-spec bulk_string(binary()) -> binary().
bulk_string(Value) ->
    <<<<<<<<"$"/utf8,
                    (begin
                        _pipe = Value,
                        _pipe@1 = erlang:byte_size(_pipe),
                        erlang:integer_to_binary(_pipe@1)
                    end)/binary>>/binary,
                "\r\n"/utf8>>/binary,
            Value/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 151).
-spec simple_error(binary()) -> binary().
simple_error(Value) ->
    <<<<"-"/utf8,
            (begin
                _pipe = Value,
                _pipe@1 = gleam@string:replace(
                    _pipe,
                    <<"\r"/utf8>>,
                    <<""/utf8>>
                ),
                gleam@string:replace(_pipe@1, <<"\n"/utf8>>, <<""/utf8>>)
            end)/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 161).
-spec bulk_error(binary()) -> binary().
bulk_error(Value) ->
    <<<<<<<<"!"/utf8,
                    (begin
                        _pipe = Value,
                        _pipe@1 = erlang:byte_size(_pipe),
                        erlang:integer_to_binary(_pipe@1)
                    end)/binary>>/binary,
                "\r\n"/utf8>>/binary,
            Value/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 173).
-spec big_number(integer()) -> binary().
big_number(Value) ->
    <<<<"("/utf8, (erlang:integer_to_binary(Value))/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 177).
-spec double(float()) -> binary().
double(Value) ->
    <<<<","/utf8, (gleam_stdlib:float_to_string(Value))/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 181).
-spec integer_as_double(integer()) -> binary().
integer_as_double(Value) ->
    <<<<","/utf8, (erlang:integer_to_binary(Value))/binary>>/binary,
        "\r\n"/utf8>>.

-file("src/valkyrie/resp.gleam", 424).
-spec consume_till_crlf(bitstring(), bitstring()) -> {ok,
        {bitstring(), bitstring()}} |
    {error, nil}.
consume_till_crlf(Data, Storage) ->
    case Data of
        <<"\r\n"/utf8, Rest/bitstring>> ->
            {ok, {Storage, Rest}};

        <<Ch:8, Rest@1/bitstring>> ->
            consume_till_crlf(Rest@1, gleam@bit_array:append(Storage, <<Ch>>));

        <<>> ->
            {ok, {Storage, <<>>}};

        _ ->
            {error, nil}
    end.

-file("src/valkyrie/resp.gleam", 437).
-spec consume_by_length(bitstring(), integer(), bitstring()) -> {ok,
        {bitstring(), bitstring()}} |
    {error, nil}.
consume_by_length(Data, Length, Storage) ->
    gleam@bool:guard(
        Length < 0,
        {ok, {Storage, Data}},
        fun() -> case erlang:byte_size(Data) of
                0 ->
                    {error, nil};

                _ ->
                    {Ch@1, Rest@1} = case Data of
                        <<Ch:8, Rest/bitstring>> -> {Ch, Rest};
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"valkyrie/resp"/utf8>>,
                                        function => <<"consume_by_length"/utf8>>,
                                        line => 447,
                                        value => _assert_fail,
                                        start => 9643,
                                        'end' => 9680,
                                        pattern_start => 9654,
                                        pattern_end => 9673})
                    end,
                    case erlang:byte_size(Storage) =:= Length of
                        true ->
                            {ok,
                                {gleam@bit_array:append(Storage, <<Ch@1>>),
                                    Rest@1}};

                        false ->
                            consume_by_length(
                                Rest@1,
                                Length,
                                gleam@bit_array:append(Storage, <<Ch@1>>)
                            )
                    end
            end end
    ).

-file("src/valkyrie/resp.gleam", 457).
-spec decode_array(bitstring(), integer(), list(value())) -> {ok,
        {list(value()), bitstring()}} |
    {error, nil}.
decode_array(Data, Length, Storage) ->
    case erlang:length(Storage) =:= Length of
        true ->
            {ok, {Storage, Data}};

        false ->
            gleam@result:'try'(
                decode_message(Data),
                fun(_use0) ->
                    {Item, Rest} = _use0,
                    decode_array(Rest, Length, lists:append(Storage, [Item]))
                end
            )
    end.

-file("src/valkyrie/resp.gleam", 264).
-spec decode_message(bitstring()) -> {ok, {value(), bitstring()}} | {error, nil}.
decode_message(Value) ->
    case Value of
        <<>> ->
            {error, nil};

        <<"_\r\n"/utf8, Rest/bitstring>> ->
            {ok, {null, Rest}};

        <<",nan\r\n"/utf8, Rest@1/bitstring>> ->
            {ok, {nan, Rest@1}};

        <<",inf\r\n"/utf8, Rest@2/bitstring>> ->
            {ok, {infinity, Rest@2}};

        <<"#t\r\n"/utf8, Rest@3/bitstring>> ->
            {ok, {{boolean, true}, Rest@3}};

        <<"#f\r\n"/utf8, Rest@4/bitstring>> ->
            {ok, {{boolean, false}, Rest@4}};

        <<",-inf\r\n"/utf8, Rest@5/bitstring>> ->
            {ok, {negative_infinity, Rest@5}};

        <<":"/utf8, Rest@6/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@6, <<>>),
                fun(_use0) ->
                    {Value@1, Rest@7} = _use0,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Value@1),
                        fun(Value@2) -> _pipe = Value@2,
                            _pipe@1 = gleam_stdlib:parse_int(_pipe),
                            _pipe@2 = gleam@result:map(
                                _pipe@1,
                                fun(Field@0) -> {integer, Field@0} end
                            ),
                            gleam@result:map(
                                _pipe@2,
                                fun(Value@3) -> {Value@3, Rest@7} end
                            ) end
                    )
                end
            );

        <<","/utf8, Rest@8/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@8, <<>>),
                fun(_use0@1) ->
                    {Value@4, Rest@9} = _use0@1,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Value@4),
                        fun(Value@5) -> case gleam_stdlib:parse_int(Value@5) of
                                {ok, Value@6} ->
                                    _pipe@5 = {begin
                                            _pipe@3 = Value@6,
                                            _pipe@4 = erlang:float(_pipe@3),
                                            {double, _pipe@4}
                                        end,
                                        Rest@9},
                                    {ok, _pipe@5};

                                {error, nil} ->
                                    _pipe@6 = Value@5,
                                    _pipe@7 = gleam_stdlib:parse_float(_pipe@6),
                                    _pipe@8 = gleam@result:map(
                                        _pipe@7,
                                        fun(Field@0) -> {double, Field@0} end
                                    ),
                                    gleam@result:map(
                                        _pipe@8,
                                        fun(Value@7) -> {Value@7, Rest@9} end
                                    )
                            end end
                    )
                end
            );

        <<"+"/utf8, Rest@10/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@10, <<>>),
                fun(_use0@2) ->
                    {Value@8, Rest@11} = _use0@2,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Value@8),
                        fun(Value@9) ->
                            _pipe@9 = {{simple_string, Value@9}, Rest@11},
                            {ok, _pipe@9}
                        end
                    )
                end
            );

        <<"-"/utf8, Rest@12/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@12, <<>>),
                fun(_use0@3) ->
                    {Value@10, Rest@13} = _use0@3,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Value@10),
                        fun(Value@11) ->
                            _pipe@10 = {{simple_error, Value@11}, Rest@13},
                            {ok, _pipe@10}
                        end
                    )
                end
            );

        <<"("/utf8, Rest@14/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@14, <<>>),
                fun(_use0@4) ->
                    {Value@12, Rest@15} = _use0@4,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Value@12),
                        fun(Value@13) -> _pipe@11 = Value@13,
                            _pipe@12 = gleam_stdlib:parse_int(_pipe@11),
                            _pipe@13 = gleam@result:map(
                                _pipe@12,
                                fun(Field@0) -> {big_number, Field@0} end
                            ),
                            gleam@result:map(
                                _pipe@13,
                                fun(Value@14) -> {Value@14, Rest@15} end
                            ) end
                    )
                end
            );

        <<"$"/utf8, Rest@16/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@16, <<>>),
                fun(_use0@5) ->
                    {Length, Rest@17} = _use0@5,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Length),
                        fun(Length@1) ->
                            gleam@result:'try'(
                                gleam_stdlib:parse_int(Length@1),
                                fun(Length@2) ->
                                    gleam@result:'try'(
                                        consume_by_length(
                                            Rest@17,
                                            Length@2 - 1,
                                            <<>>
                                        ),
                                        fun(_use0@6) ->
                                            {Value@15, Rest@18} = _use0@6,
                                            gleam@result:'try'(
                                                gleam@bit_array:to_string(
                                                    Value@15
                                                ),
                                                fun(Value@16) ->
                                                    Rest@20 = case Rest@18 of
                                                        <<"\r\n"/utf8,
                                                            Rest@19/bitstring>> -> Rest@19;
                                                        _assert_fail ->
                                                            erlang:error(
                                                                    #{gleam_error => let_assert,
                                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                        file => <<?FILEPATH/utf8>>,
                                                                        module => <<"valkyrie/resp"/utf8>>,
                                                                        function => <<"decode_message"/utf8>>,
                                                                        line => 343,
                                                                        value => _assert_fail,
                                                                        start => 6961,
                                                                        'end' => 7005,
                                                                        pattern_start => 6972,
                                                                        pattern_end => 6998}
                                                                )
                                                    end,
                                                    _pipe@14 = {{bulk_string,
                                                            Value@16},
                                                        Rest@20},
                                                    {ok, _pipe@14}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"!"/utf8, Rest@21/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@21, <<>>),
                fun(_use0@7) ->
                    {Length@3, Rest@22} = _use0@7,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Length@3),
                        fun(Length@4) ->
                            gleam@result:'try'(
                                gleam_stdlib:parse_int(Length@4),
                                fun(Length@5) ->
                                    gleam@result:'try'(
                                        consume_by_length(
                                            Rest@22,
                                            Length@5 - 1,
                                            <<>>
                                        ),
                                        fun(_use0@8) ->
                                            {Value@17, Rest@23} = _use0@8,
                                            gleam@result:'try'(
                                                gleam@bit_array:to_string(
                                                    Value@17
                                                ),
                                                fun(Value@18) ->
                                                    Rest@25 = case Rest@23 of
                                                        <<"\r\n"/utf8,
                                                            Rest@24/bitstring>> -> Rest@24;
                                                        _assert_fail@1 ->
                                                            erlang:error(
                                                                    #{gleam_error => let_assert,
                                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                        file => <<?FILEPATH/utf8>>,
                                                                        module => <<"valkyrie/resp"/utf8>>,
                                                                        function => <<"decode_message"/utf8>>,
                                                                        line => 358,
                                                                        value => _assert_fail@1,
                                                                        start => 7437,
                                                                        'end' => 7481,
                                                                        pattern_start => 7448,
                                                                        pattern_end => 7474}
                                                                )
                                                    end,
                                                    _pipe@15 = {{bulk_error,
                                                            Value@18},
                                                        Rest@25},
                                                    {ok, _pipe@15}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"*"/utf8, Rest@26/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@26, <<>>),
                fun(_use0@9) ->
                    {Length@6, Rest@27} = _use0@9,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Length@6),
                        fun(Length@7) ->
                            gleam@result:'try'(
                                gleam_stdlib:parse_int(Length@7),
                                fun(Length@8) ->
                                    gleam@result:'try'(
                                        decode_array(Rest@27, Length@8, []),
                                        fun(_use0@10) ->
                                            {Value@19, Rest@28} = _use0@10,
                                            _pipe@17 = {begin
                                                    _pipe@16 = Value@19,
                                                    {array, _pipe@16}
                                                end,
                                                Rest@28},
                                            {ok, _pipe@17}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<">"/utf8, Rest@29/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@29, <<>>),
                fun(_use0@11) ->
                    {Length@9, Rest@30} = _use0@11,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Length@9),
                        fun(Length@10) ->
                            gleam@result:'try'(
                                gleam_stdlib:parse_int(Length@10),
                                fun(Length@11) ->
                                    gleam@result:'try'(
                                        decode_array(Rest@30, Length@11, []),
                                        fun(_use0@12) ->
                                            {Value@20, Rest@31} = _use0@12,
                                            _pipe@19 = {begin
                                                    _pipe@18 = Value@20,
                                                    {push, _pipe@18}
                                                end,
                                                Rest@31},
                                            {ok, _pipe@19}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"~"/utf8, Rest@32/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@32, <<>>),
                fun(_use0@13) ->
                    {Length@12, Rest@33} = _use0@13,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Length@12),
                        fun(Length@13) ->
                            gleam@result:'try'(
                                gleam_stdlib:parse_int(Length@13),
                                fun(Length@14) ->
                                    gleam@result:'try'(
                                        decode_array(Rest@33, Length@14, []),
                                        fun(_use0@14) ->
                                            {Value@21, Rest@34} = _use0@14,
                                            _pipe@22 = {begin
                                                    _pipe@20 = Value@21,
                                                    _pipe@21 = gleam@set:from_list(
                                                        _pipe@20
                                                    ),
                                                    {set, _pipe@21}
                                                end,
                                                Rest@34},
                                            {ok, _pipe@22}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"%"/utf8, Rest@35/bitstring>> ->
            gleam@result:'try'(
                consume_till_crlf(Rest@35, <<>>),
                fun(_use0@15) ->
                    {Length@15, Rest@36} = _use0@15,
                    gleam@result:'try'(
                        gleam@bit_array:to_string(Length@15),
                        fun(Length@16) ->
                            gleam@result:'try'(
                                gleam_stdlib:parse_int(Length@16),
                                fun(Length@17) ->
                                    gleam@result:'try'(
                                        decode_map(Rest@36, Length@17, []),
                                        fun(_use0@16) ->
                                            {Value@22, Rest@37} = _use0@16,
                                            _pipe@24 = {begin
                                                    _pipe@23 = Value@22,
                                                    {map, _pipe@23}
                                                end,
                                                Rest@37},
                                            {ok, _pipe@24}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, nil}
    end.

-file("src/valkyrie/resp.gleam", 251).
-spec decode_multiple(bitstring(), list(value())) -> {ok, list(value())} |
    {error, nil}.
decode_multiple(Value, Storage) ->
    gleam@result:'try'(
        decode_message(Value),
        fun(Value@1) ->
            Storage@1 = lists:append(Storage, [erlang:element(1, Value@1)]),
            case Value@1 of
                {_, <<>>} ->
                    {ok, Storage@1};

                {_, Rest} ->
                    decode_multiple(Rest, Storage@1)
            end
        end
    ).

-file("src/valkyrie/resp.gleam", 247).
?DOC(false).
-spec decode_value(bitstring()) -> {ok, list(value())} | {error, nil}.
decode_value(Value) ->
    decode_multiple(Value, []).

-file("src/valkyrie/resp.gleam", 467).
-spec decode_map(bitstring(), integer(), list({value(), value()})) -> {ok,
        {gleam@dict:dict(value(), value()), bitstring()}} |
    {error, nil}.
decode_map(Data, Length, Storage) ->
    case erlang:length(Storage) =:= Length of
        true ->
            {ok, {maps:from_list(Storage), Data}};

        false ->
            gleam@result:'try'(
                decode_message(Data),
                fun(_use0) ->
                    {Key, Rest} = _use0,
                    gleam@result:'try'(
                        decode_message(Rest),
                        fun(_use0@1) ->
                            {Value, Rest@1} = _use0@1,
                            decode_map(
                                Rest@1,
                                Length,
                                lists:append(Storage, [{Key, Value}])
                            )
                        end
                    )
                end
            )
    end.

-file("src/valkyrie/resp.gleam", 185).
-spec array(list(value())) -> binary().
array(Value) ->
    <<<<<<"*"/utf8,
                (begin
                    _pipe = Value,
                    _pipe@1 = erlang:length(_pipe),
                    erlang:integer_to_binary(_pipe@1)
                end)/binary>>/binary,
            "\r\n"/utf8>>/binary,
        (begin
            _pipe@2 = gleam@list:map(Value, fun encode_value/1),
            gleam@string:join(_pipe@2, <<""/utf8>>)
        end)/binary>>.

-file("src/valkyrie/resp.gleam", 80).
-spec encode_value(value()) -> binary().
encode_value(Value) ->
    case Value of
        nan ->
            nan();

        null ->
            null();

        infinity ->
            infinity();

        {set, Value@1} ->
            set(Value@1);

        {map, Value@2} ->
            map(Value@2);

        {push, Value@3} ->
            push(Value@3);

        {array, Value@4} ->
            array(Value@4);

        {double, Value@5} ->
            double(Value@5);

        {boolean, Value@6} ->
            boolean(Value@6);

        {integer, Value@7} ->
            integer(Value@7);

        {big_number, Value@8} ->
            big_number(Value@8);

        {bulk_error, Value@9} ->
            bulk_error(Value@9);

        {bulk_string, Value@10} ->
            bulk_string(Value@10);

        negative_infinity ->
            negative_infinity();

        {simple_error, Value@11} ->
            simple_error(Value@11);

        {simple_string, Value@12} ->
            simple_string(Value@12);

        {integer_as_double, Value@13} ->
            integer_as_double(Value@13)
    end.

-file("src/valkyrie/resp.gleam", 72).
?DOC(false).
-spec encode_command(list(binary())) -> bitstring().
encode_command(Parts) ->
    _pipe = Parts,
    _pipe@1 = gleam@list:map(_pipe, fun(Field@0) -> {bulk_string, Field@0} end),
    _pipe@2 = {array, _pipe@1},
    _pipe@3 = encode_value(_pipe@2),
    gleam_stdlib:identity(_pipe@3).

-file("src/valkyrie/resp.gleam", 199).
-spec map(gleam@dict:dict(value(), value())) -> binary().
map(Value) ->
    <<<<<<"%"/utf8,
                (begin
                    _pipe = Value,
                    _pipe@1 = maps:size(_pipe),
                    erlang:integer_to_binary(_pipe@1)
                end)/binary>>/binary,
            "\r\n"/utf8>>/binary,
        (begin
            _pipe@2 = Value,
            _pipe@3 = maps:to_list(_pipe@2),
            _pipe@4 = gleam@list:map(
                _pipe@3,
                fun(Item) ->
                    <<(encode_value(erlang:element(1, Item)))/binary,
                        (encode_value(erlang:element(2, Item)))/binary>>
                end
            ),
            gleam@string:join(_pipe@4, <<""/utf8>>)
        end)/binary>>.

-file("src/valkyrie/resp.gleam", 215).
-spec push(list(value())) -> binary().
push(Value) ->
    <<<<<<">"/utf8,
                (begin
                    _pipe = Value,
                    _pipe@1 = erlang:length(_pipe),
                    erlang:integer_to_binary(_pipe@1)
                end)/binary>>/binary,
            "\r\n"/utf8>>/binary,
        (begin
            _pipe@2 = gleam@list:map(Value, fun encode_value/1),
            gleam@string:join(_pipe@2, <<""/utf8>>)
        end)/binary>>.

-file("src/valkyrie/resp.gleam", 229).
-spec set(gleam@set:set(value())) -> binary().
set(Value) ->
    Value@1 = gleam@set:to_list(Value),
    <<<<<<"~"/utf8,
                (begin
                    _pipe = Value@1,
                    _pipe@1 = erlang:length(_pipe),
                    erlang:integer_to_binary(_pipe@1)
                end)/binary>>/binary,
            "\r\n"/utf8>>/binary,
        (begin
            _pipe@2 = gleam@list:map(Value@1, fun encode_value/1),
            gleam@string:join(_pipe@2, <<""/utf8>>)
        end)/binary>>.