shimmer

-module(shimmer@ws@packet).
-compile(no_auto_import).

-export([from_dynamic/1]).

-spec from_dynamic(gleam@dynamic:dynamic()) -> {ok,
        {integer(),
            gleam@option:option(integer()),
            gleam@option:option(binary()),
            gleam@option:option(gleam@map:map_(gleam@dynamic:dynamic(), gleam@dynamic:dynamic()))}} |
    {error, shimmer@internal@error:shimmer_error()}.
from_dynamic(Encoded) ->
    case begin
        _pipe = Encoded,
        _pipe@1 = (gleam@dynamic:map(
            fun gleam@dynamic:dynamic/1,
            fun gleam@dynamic:dynamic/1
        ))(_pipe),
        gleam@result:map_error(
            _pipe@1,
            fun(Field@0) -> {invalid_dynamic_list, Field@0} end
        )
    end of
        {error, _try} -> {error, _try};
        {ok, Packet} ->
            case begin
                _pipe@2 = Packet,
                shimmer@internal@map_helpers:get_field_safe(
                    _pipe@2,
                    shimmer@internal@map_helpers:dyn_atom(<<"op"/utf8>>),
                    fun gleam@dynamic:int/1
                )
            end of
                {error, _try@1} -> {error, _try@1};
                {ok, Op} ->
                    case begin
                        _pipe@3 = Packet,
                        shimmer@internal@map_helpers:get_field_safe(
                            _pipe@3,
                            shimmer@internal@map_helpers:dyn_atom(<<"s"/utf8>>),
                            gleam@dynamic:optional(fun gleam@dynamic:int/1)
                        )
                    end of
                        {error, _try@2} -> {error, _try@2};
                        {ok, S} ->
                            case begin
                                _pipe@4 = Packet,
                                shimmer@internal@map_helpers:get_field_safe(
                                    _pipe@4,
                                    shimmer@internal@map_helpers:dyn_atom(
                                        <<"t"/utf8>>
                                    ),
                                    gleam@dynamic:optional(
                                        fun gleam@erlang@atom:from_dynamic/1
                                    )
                                )
                            end of
                                {error, _try@3} -> {error, _try@3};
                                {ok, T_atom} ->
                                    T = case T_atom of
                                        {some, A} ->
                                            {some, erlang:atom_to_binary(A)};

                                        _@1 ->
                                            none
                                    end,
                                    case begin
                                        _pipe@5 = Packet,
                                        shimmer@internal@map_helpers:get_field_safe(
                                            _pipe@5,
                                            shimmer@internal@map_helpers:dyn_atom(
                                                <<"d"/utf8>>
                                            ),
                                            gleam@dynamic:optional(
                                                gleam@dynamic:map(
                                                    fun gleam@dynamic:dynamic/1,
                                                    fun gleam@dynamic:dynamic/1
                                                )
                                            )
                                        )
                                    end of
                                        {error, _try@4} -> {error, _try@4};
                                        {ok, D} ->
                                            {ok, {Op, S, T, D}}
                                    end
                            end
                    end
            end
    end.