shimmer

-module(shimmer@types@user).
-compile(no_auto_import).

-export([from_json_string/1]).
-export_type([user/0]).

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

-spec from_json_string(binary()) -> {ok, user()} |
    {error, shimmer@internal@error:shimmer_error()}.
from_json_string(Encoded) ->
    case begin
        _pipe = gleam@json:decode(Encoded),
        gleam@result:map_error(_pipe, fun(A) -> {invalid_json, A} end)
    end of
        {error, _try} -> {error, _try};
        {ok, Data} ->
            Data@1 = gleam@dynamic:from(Data),
            case begin
                _pipe@1 = case gleam@dynamic:field(Data@1, <<"id"/utf8>>) of
                    {error, _try@1} -> {error, _try@1};
                    {ok, Id} ->
                        case gleam@dynamic:string(Id) of
                            {error, _try@2} -> {error, _try@2};
                            {ok, Id@1} ->
                                case gleam@dynamic:field(
                                    Data@1,
                                    <<"username"/utf8>>
                                ) of
                                    {error, _try@3} -> {error, _try@3};
                                    {ok, Username} ->
                                        case gleam@dynamic:string(Username) of
                                            {error, _try@4} -> {error, _try@4};
                                            {ok, Username@1} ->
                                                case gleam@dynamic:field(
                                                    Data@1,
                                                    <<"discriminator"/utf8>>
                                                ) of
                                                    {error, _try@5} -> {error, _try@5};
                                                    {ok, Discriminator} ->
                                                        case gleam@dynamic:string(
                                                            Discriminator
                                                        ) of
                                                            {error, _try@6} -> {error, _try@6};
                                                            {ok, Discriminator@1} ->
                                                                case gleam@dynamic:field(
                                                                    Data@1,
                                                                    <<"bot"/utf8>>
                                                                ) of
                                                                    {error, _try@7} -> {error, _try@7};
                                                                    {ok, Is_bot} ->
                                                                        case gleam@dynamic:bool(
                                                                            Is_bot
                                                                        ) of
                                                                            {error, _try@8} -> {error, _try@8};
                                                                            {ok, Is_bot@1} ->
                                                                                {ok,
                                                                                 {user,
                                                                                  Id@1,
                                                                                  Username@1,
                                                                                  Discriminator@1,
                                                                                  Is_bot@1}}
                                                                        end
                                                                end
                                                        end
                                                end
                                        end
                                end
                        end
                end,
                gleam@result:map_error(
                    _pipe@1,
                    fun(A) -> {invalid_format, A} end
                )
            end of
                {error, _try@9} -> {error, _try@9};
                {ok, User} ->
                    {ok, User}
            end
    end.