shimmer

-module(shimmer@ws@packets@message_create).
-compile(no_auto_import).

-export([from_map/1]).
-export_type([message_create/0]).

-type message_create() :: {message_create,
        shimmer@types@message:message(),
        gleam@option:option(binary()),
        gleam@option:option(shimmer@types@member:member()),
        list(shimmer@types@user:user())}.

-spec from_map(gleam@map:map_(gleam@dynamic:dynamic(), gleam@dynamic:dynamic())) -> {ok,
        message_create()} |
    {error, shimmer@internal@error:shimmer_error()}.
from_map(Map) ->
    case begin
        _pipe = Map,
        shimmer@types@message:from_map(_pipe)
    end of
        {error, _try} -> {error, _try};
        {ok, Message} ->
            case begin
                _pipe@1 = Map,
                shimmer@internal@map_helpers:get_field_safe(
                    _pipe@1,
                    shimmer@internal@map_helpers:dyn_atom(<<"guild_id"/utf8>>),
                    gleam@dynamic:optional(fun shimmer@snowflake:from_dynamic/1)
                )
            end of
                {error, _try@1} -> {error, _try@1};
                {ok, Guild_id} ->
                    case begin
                        _pipe@2 = Map,
                        shimmer@internal@map_helpers:get_field_safe(
                            _pipe@2,
                            shimmer@internal@map_helpers:dyn_key(
                                <<"mentions"/utf8>>
                            ),
                            gleam@dynamic:list(
                                gleam@dynamic:map(
                                    fun gleam@dynamic:dynamic/1,
                                    fun gleam@dynamic:dynamic/1
                                )
                            )
                        )
                    end of
                        {error, _try@2} -> {error, _try@2};
                        {ok, Mentions_raw} ->
                            case begin
                                _pipe@3 = Mentions_raw,
                                gleam@list:try_map(
                                    _pipe@3,
                                    fun(User_map) ->
                                        case begin
                                            _pipe@4 = User_map,
                                            shimmer@types@user:from_map(
                                                _pipe@4,
                                                fun shimmer@internal@map_helpers:dyn_key/1
                                            )
                                        end of
                                            {error, _try@3} -> {error, _try@3};
                                            {ok, User_cast} ->
                                                {ok, User_cast}
                                        end
                                    end
                                )
                            end of
                                {error, _try@4} -> {error, _try@4};
                                {ok, Mentions} ->
                                    {ok,
                                        {message_create,
                                            Message,
                                            Guild_id,
                                            none,
                                            Mentions}}
                            end
                    end
            end
    end.