-module(jsonrpcx).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/jsonrpcx.gleam").
-export([batch_request_items/1, batch_request/0, add_request/3, add_notification/3, batch_response_items/1, batch_response/0, add_response/3, add_error_response/3, version_to_json/1, version_decoder/0, id/1, id_to_json/1, id_decoder/0, request/2, request_params/2, request_to_json/2, request_decoder/1, nothing_to_json/1, nothing_decoder/0, notification/1, notification_params/2, notification_to_json/2, batch_request_item_to_json/1, batch_request_to_json/1, notification_decoder/1, batch_request_item_decoder/0, batch_request_decoder/0, response/2, response_to_json/2, response_decoder/1, error_response/2, error_response_data/2, error_to_json/2, error_response_to_json/2, batch_response_item_to_json/1, batch_response_to_json/1, error_decoder/1, error_response_decoder/1, batch_response_item_decoder/0, batch_response_decoder/0, message_decoder/0, error_code/1, error_message/1, application_error/2, server_error/1, error_response_from/2, decode_errors/1, json_error/1]).
-export_type([message/0, batch_request/1, batch_request_item/1, batch_response/1, batch_response_item/1, version/0, id/0, request/1, nothing/0, notification/1, response/1, error_response/1, error_body/1, json_rpc_error/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.

?MODULEDOC(
    " JSON-RPC is a stateless, light-weight remote procedure call (RPC) protocol.\n"
    " Primarily this specification defines several data structures and the rules\n"
    " around their processing. It is transport agnostic in that the concepts can be\n"
    " used within the same process, over sockets, over http, or in many various\n"
    " message passing environments. It uses JSON (RFC 4627) as data format.\n"
    "\n"
    " The error codes from and including -32768 to -32000 are reserved for\n"
    " pre-defined errors. Any code within this range, but not defined explicitly below\n"
    " is reserved for future use.\n"
    "\n"
    " | code | message | meaning |\n"
    " | --- | --- | --- |\n"
    " | -32700 | Parse error | Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text. |\n"
    " | -32600 | Invalid Request | The JSON sent is not a valid Request object. |\n"
    " | -32601 | Method not found | The method does not exist / is not available. |\n"
    " | -32602 | Invalid params | Invalid method parameter(s). |\n"
    " | -32603 | Internal error | Internal JSON-RPC error. |\n"
    " | -32000 to -32099 | Server error | Reserved for implementation-defined server-errors. |\n"
    "\n"
    " The remainder of the space is available for application defined errors.\n"
).

-type message() :: {request_message, request(gleam@dynamic:dynamic_())} |
    {notification_message, notification(gleam@dynamic:dynamic_())} |
    {response_message, response(gleam@dynamic:dynamic_())} |
    {error_response_message, error_response(gleam@dynamic:dynamic_())} |
    {batch_request_message, batch_request(gleam@dynamic:dynamic_())} |
    {batch_response_message, batch_response(gleam@dynamic:dynamic_())}.

-opaque batch_request(KEX) :: {batch_request, list(batch_request_item(KEX))}.

-type batch_request_item(KEY) :: {batch_request_item_request, request(KEY)} |
    {batch_request_item_notification, notification(KEY)}.

-opaque batch_response(KEZ) :: {batch_response, list(batch_response_item(KEZ))}.

-type batch_response_item(KFA) :: {batch_response_item_response, response(KFA)} |
    {batch_response_item_error_response, error_response(KFA)}.

-type version() :: v2.

-type id() :: {string_id, binary()} | {int_id, integer()} | null_id.

-type request(KFB) :: {request,
        version(),
        binary(),
        id(),
        gleam@option:option(KFB)}.

-opaque nothing() :: nothing.

-type notification(KFC) :: {notification,
        version(),
        binary(),
        gleam@option:option(KFC)}.

-type response(KFD) :: {response, version(), id(), KFD}.

-type error_response(KFE) :: {error_response, version(), id(), error_body(KFE)}.

-type error_body(KFF) :: {error_body,
        integer(),
        binary(),
        gleam@option:option(KFF)}.

-opaque json_rpc_error() :: {json_rpc_error, integer(), binary()}.

-file("src/jsonrpcx.gleam", 66).
?DOC(" retrieve the list of BatchRequestItems\n").
-spec batch_request_items(batch_request(KFH)) -> list(batch_request_item(KFH)).
batch_request_items(Batch_request) ->
    {batch_request, Batch} = Batch_request,
    Batch.

-file("src/jsonrpcx.gleam", 74).
?DOC(" Create a new, empty batch request\n").
-spec batch_request() -> batch_request(gleam@json:json()).
batch_request() ->
    {batch_request, []}.

-file("src/jsonrpcx.gleam", 89).
?DOC(
    " Add a request to a batch request. Batch requests have no guarantees about\n"
    " order. Therefore order is not preserved when your batch request is sent.\n"
).
-spec add_request(
    batch_request(gleam@json:json()),
    request(KFQ),
    fun((KFQ) -> gleam@json:json())
) -> batch_request(gleam@json:json()).
add_request(Batch_request, Request, Params_to_json) ->
    {batch_request, Batch} = Batch_request,
    Request@1 = begin
        _pipe = {request,
            erlang:element(2, Request),
            erlang:element(3, Request),
            erlang:element(4, Request),
            gleam@option:map(erlang:element(5, Request), Params_to_json)},
        {batch_request_item_request, _pipe}
    end,
    {batch_request, [Request@1 | Batch]}.

-file("src/jsonrpcx.gleam", 103).
?DOC(
    " Add a notification to a batch request. Batch requests have no guarantees about\n"
    " order. Therefore order is not preserved when your batch request is sent.\n"
).
-spec add_notification(
    batch_request(gleam@json:json()),
    notification(KFU),
    fun((KFU) -> gleam@json:json())
) -> batch_request(gleam@json:json()).
add_notification(Batch_request, Notification, Params_to_json) ->
    {batch_request, Batch} = Batch_request,
    Notification@1 = begin
        _pipe = {notification,
            erlang:element(2, Notification),
            erlang:element(3, Notification),
            gleam@option:map(erlang:element(4, Notification), Params_to_json)},
        {batch_request_item_notification, _pipe}
    end,
    {batch_request, [Notification@1 | Batch]}.

-file("src/jsonrpcx.gleam", 153).
?DOC(" retrieve the list of BatchResponseItems\n").
-spec batch_response_items(batch_response(KGB)) -> list(batch_response_item(KGB)).
batch_response_items(Batch_response) ->
    {batch_response, Batch} = Batch_response,
    Batch.

-file("src/jsonrpcx.gleam", 159).
?DOC(" Create a new, empty batch response\n").
-spec batch_response() -> batch_response(gleam@json:json()).
batch_response() ->
    {batch_response, []}.

-file("src/jsonrpcx.gleam", 174).
?DOC(
    " Add a response to a batch response. Batch responses have no guarantees about\n"
    " order. Therefore order is not preserved when your batch response is sent.\n"
).
-spec add_response(
    batch_response(gleam@json:json()),
    response(KGK),
    fun((KGK) -> gleam@json:json())
) -> batch_response(gleam@json:json()).
add_response(Batch_response, Response, Result_to_json) ->
    {batch_response, Batch} = Batch_response,
    Response@1 = begin
        _pipe = {response,
            erlang:element(2, Response),
            erlang:element(3, Response),
            Result_to_json(erlang:element(4, Response))},
        {batch_response_item_response, _pipe}
    end,
    {batch_response, [Response@1 | Batch]}.

-file("src/jsonrpcx.gleam", 188).
?DOC(
    " Add an error response to a batch response. Batch responses have no guarantees about\n"
    " order. Therefore order is not preserved when your batch response is sent.\n"
).
-spec add_error_response(
    batch_response(gleam@json:json()),
    error_response(KGO),
    fun((KGO) -> gleam@json:json())
) -> batch_response(gleam@json:json()).
add_error_response(Batch_response, Error_response, Data_to_json) ->
    {batch_response, Batch} = Batch_response,
    Error = begin
        _record = erlang:element(4, Error_response),
        {error_body,
            erlang:element(2, _record),
            erlang:element(3, _record),
            gleam@option:map(
                erlang:element(4, erlang:element(4, Error_response)),
                Data_to_json
            )}
    end,
    Error_response@1 = begin
        _pipe = {error_response,
            erlang:element(2, Error_response),
            erlang:element(3, Error_response),
            Error},
        {batch_response_item_error_response, _pipe}
    end,
    {batch_response, [Error_response@1 | Batch]}.

-file("src/jsonrpcx.gleam", 234).
-spec version_to_json(version()) -> gleam@json:json().
version_to_json(_) ->
    gleam@json:string(<<"2.0"/utf8>>).

-file("src/jsonrpcx.gleam", 238).
-spec version_decoder() -> gleam@dynamic@decode:decoder(version()).
version_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(V) -> case V of
                <<"2.0"/utf8>> ->
                    gleam@dynamic@decode:success(v2);

                _ ->
                    gleam@dynamic@decode:failure(
                        v2,
                        <<"unsupported JSON-RPC version: "/utf8, V/binary>>
                    )
            end end
    ).

-file("src/jsonrpcx.gleam", 255).
?DOC(" Creates an Int ID\n").
-spec id(integer()) -> id().
id(Id) ->
    {int_id, Id}.

-file("src/jsonrpcx.gleam", 259).
-spec id_to_json(id()) -> gleam@json:json().
id_to_json(Id) ->
    case Id of
        {int_id, Id@1} ->
            gleam@json:int(Id@1);

        null_id ->
            gleam@json:null();

        {string_id, Id@2} ->
            gleam@json:string(Id@2)
    end.

-file("src/jsonrpcx.gleam", 267).
-spec id_decoder() -> gleam@dynamic@decode:decoder(id()).
id_decoder() ->
    String_decoder = begin
        _pipe = {decoder, fun gleam@dynamic@decode:decode_string/1},
        gleam@dynamic@decode:map(
            _pipe,
            fun(Field@0) -> {string_id, Field@0} end
        )
    end,
    Others = begin
        _pipe@2 = gleam@dynamic@decode:optional(
            begin
                _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
                gleam@dynamic@decode:map(
                    _pipe@1,
                    fun(Field@0) -> {int_id, Field@0} end
                )
            end
        ),
        gleam@dynamic@decode:map(
            _pipe@2,
            fun(_capture) -> gleam@option:unwrap(_capture, null_id) end
        )
    end,
    gleam@dynamic@decode:one_of(String_decoder, [Others]).

-file("src/jsonrpcx.gleam", 296).
?DOC(" Creates a new request with empty params\n").
-spec request(binary(), id()) -> request(any()).
request(Method, Id) ->
    {request, v2, Method, Id, none}.

-file("src/jsonrpcx.gleam", 301).
?DOC(" Sets the params of this request\n").
-spec request_params(request(any()), KHB) -> request(KHB).
request_params(Request, Params) ->
    {request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        {some, Params}}.

-file("src/jsonrpcx.gleam", 305).
-spec request_to_json(request(KHD), fun((KHD) -> gleam@json:json())) -> gleam@json:json().
request_to_json(Request, Encode_params) ->
    {request, Jsonrpc, Method, Id, Params} = Request,
    Params@2 = case Params of
        {some, Params@1} ->
            [{<<"params"/utf8>>, Encode_params(Params@1)}];

        none ->
            []
    end,
    gleam@json:object(
        [{<<"jsonrpc"/utf8>>, version_to_json(Jsonrpc)},
            {<<"method"/utf8>>, gleam@json:string(Method)},
            {<<"id"/utf8>>, id_to_json(Id)} |
            Params@2]
    ).

-file("src/jsonrpcx.gleam", 322).
-spec request_decoder(gleam@dynamic@decode:decoder(KHF)) -> gleam@dynamic@decode:decoder(request(KHF)).
request_decoder(Params_decoder) ->
    gleam@dynamic@decode:field(
        <<"jsonrpc"/utf8>>,
        version_decoder(),
        fun(Jsonrpc) ->
            gleam@dynamic@decode:field(
                <<"method"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Method) ->
                    gleam@dynamic@decode:field(
                        <<"id"/utf8>>,
                        id_decoder(),
                        fun(Id) ->
                            gleam@dynamic@decode:optional_field(
                                <<"params"/utf8>>,
                                none,
                                gleam@dynamic@decode:optional(Params_decoder),
                                fun(Params) ->
                                    gleam@dynamic@decode:success(
                                        {request, Jsonrpc, Method, Id, Params}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/jsonrpcx.gleam", 345).
?DOC(
    " Encode json for the Nothing type, which is impossible to create. This\n"
    " is intended for fields you KNOW are omitted, and therefore it will never be\n"
    " ran. It will always return `null` if ran.\n"
).
-spec nothing_to_json(nothing()) -> gleam@json:json().
nothing_to_json(_) ->
    gleam@json:null().

-file("src/jsonrpcx.gleam", 352).
?DOC(
    " A decoder for the Nothing type, which is impossible to create. This decoder\n"
    " is intended for fields you KNOW are omitted, and therefore it will never be\n"
    " ran. It will always fail if ran\n"
).
-spec nothing_decoder() -> gleam@dynamic@decode:decoder(nothing()).
nothing_decoder() ->
    gleam@dynamic@decode:failure(
        nothing,
        <<"Attempted to decode a Nothing type."/utf8>>
    ).

-file("src/jsonrpcx.gleam", 380).
?DOC(" Creates a new notification with empty params\n").
-spec notification(binary()) -> notification(any()).
notification(Method) ->
    {notification, v2, Method, none}.

-file("src/jsonrpcx.gleam", 385).
?DOC(" Sets the params for this notification\n").
-spec notification_params(notification(any()), KHO) -> notification(KHO).
notification_params(Notification, Params) ->
    {notification,
        erlang:element(2, Notification),
        erlang:element(3, Notification),
        {some, Params}}.

-file("src/jsonrpcx.gleam", 392).
-spec notification_to_json(notification(KHQ), fun((KHQ) -> gleam@json:json())) -> gleam@json:json().
notification_to_json(Notification, Encode_params) ->
    {notification, Jsonrpc, Method, Params} = Notification,
    Params@2 = case Params of
        {some, Params@1} ->
            [{<<"params"/utf8>>, Encode_params(Params@1)}];

        none ->
            []
    end,
    gleam@json:object(
        [{<<"jsonrpc"/utf8>>, version_to_json(Jsonrpc)},
            {<<"method"/utf8>>, gleam@json:string(Method)} |
            Params@2]
    ).

-file("src/jsonrpcx.gleam", 135).
-spec batch_request_item_to_json(batch_request_item(gleam@json:json())) -> gleam@json:json().
batch_request_item_to_json(Item) ->
    case Item of
        {batch_request_item_request, Msg} ->
            request_to_json(Msg, fun gleam@function:identity/1);

        {batch_request_item_notification, Msg@1} ->
            notification_to_json(Msg@1, fun gleam@function:identity/1)
    end.

-file("src/jsonrpcx.gleam", 78).
-spec batch_request_to_json(batch_request(gleam@json:json())) -> gleam@json:json().
batch_request_to_json(Batch_request) ->
    {batch_request, Batch} = Batch_request,
    gleam@json:array(Batch, fun batch_request_item_to_json/1).

-file("src/jsonrpcx.gleam", 409).
-spec notification_decoder(gleam@dynamic@decode:decoder(KHS)) -> gleam@dynamic@decode:decoder(notification(KHS)).
notification_decoder(Params_decoder) ->
    gleam@dynamic@decode:field(
        <<"jsonrpc"/utf8>>,
        version_decoder(),
        fun(Jsonrpc) ->
            gleam@dynamic@decode:field(
                <<"method"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Method) ->
                    gleam@dynamic@decode:optional_field(
                        <<"params"/utf8>>,
                        none,
                        gleam@dynamic@decode:optional(Params_decoder),
                        fun(Params) ->
                            gleam@dynamic@decode:success(
                                {notification, Jsonrpc, Method, Params}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/jsonrpcx.gleam", 125).
-spec batch_request_item_decoder() -> gleam@dynamic@decode:decoder(batch_request_item(gleam@dynamic:dynamic_())).
batch_request_item_decoder() ->
    Request = begin
        _pipe = request_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe,
            fun(Field@0) -> {batch_request_item_request, Field@0} end
        )
    end,
    Notification = begin
        _pipe@1 = notification_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe@1,
            fun(Field@0) -> {batch_request_item_notification, Field@0} end
        )
    end,
    gleam@dynamic@decode:one_of(Request, [Notification]).

-file("src/jsonrpcx.gleam", 83).
-spec batch_request_decoder() -> gleam@dynamic@decode:decoder(batch_request(gleam@dynamic:dynamic_())).
batch_request_decoder() ->
    _pipe = gleam@dynamic@decode:list(batch_request_item_decoder()),
    gleam@dynamic@decode:map(
        _pipe,
        fun(Field@0) -> {batch_request, Field@0} end
    ).

-file("src/jsonrpcx.gleam", 437).
?DOC(" Creates a new response\n").
-spec response(KHW, id()) -> response(KHW).
response(Result, Id) ->
    {response, v2, Id, Result}.

-file("src/jsonrpcx.gleam", 441).
-spec response_to_json(response(KHY), fun((KHY) -> gleam@json:json())) -> gleam@json:json().
response_to_json(Response, Encode_result) ->
    {response, Jsonrpc, Id, Result} = Response,
    gleam@json:object(
        [{<<"jsonrpc"/utf8>>, version_to_json(Jsonrpc)},
            {<<"id"/utf8>>, id_to_json(Id)},
            {<<"result"/utf8>>, Encode_result(Result)}]
    ).

-file("src/jsonrpcx.gleam", 453).
-spec response_decoder(gleam@dynamic@decode:decoder(KIA)) -> gleam@dynamic@decode:decoder(response(KIA)).
response_decoder(Result_decoder) ->
    gleam@dynamic@decode:field(
        <<"jsonrpc"/utf8>>,
        version_decoder(),
        fun(Jsonrpc) ->
            gleam@dynamic@decode:field(
                <<"id"/utf8>>,
                id_decoder(),
                fun(Id) ->
                    gleam@dynamic@decode:field(
                        <<"result"/utf8>>,
                        Result_decoder,
                        fun(Result) ->
                            gleam@dynamic@decode:success(
                                {response, Jsonrpc, Id, Result}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/jsonrpcx.gleam", 481).
?DOC(
    " Creates a new error response with empty data. Error code and message are\n"
    " populated with the values from `error`.\n"
).
-spec error_response(json_rpc_error(), id()) -> error_response(any()).
error_response(Error, Id) ->
    {error_response,
        v2,
        Id,
        {error_body, erlang:element(2, Error), erlang:element(3, Error), none}}.

-file("src/jsonrpcx.gleam", 493).
?DOC(" Sets the data of this error response\n").
-spec error_response_data(error_response(any()), KII) -> error_response(KII).
error_response_data(Error_response, Data) ->
    Error = begin
        _record = erlang:element(4, Error_response),
        {error_body,
            erlang:element(2, _record),
            erlang:element(3, _record),
            {some, Data}}
    end,
    {error_response,
        erlang:element(2, Error_response),
        erlang:element(3, Error_response),
        Error}.

-file("src/jsonrpcx.gleam", 540).
-spec error_to_json(error_body(KIQ), fun((KIQ) -> gleam@json:json())) -> gleam@json:json().
error_to_json(Error, Encode_data) ->
    {error_body, Code, Message, Data} = Error,
    Data@2 = case Data of
        {some, Data@1} ->
            [{<<"data"/utf8>>, Encode_data(Data@1)}];

        none ->
            []
    end,
    gleam@json:object(
        [{<<"code"/utf8>>, gleam@json:int(Code)},
            {<<"message"/utf8>>, gleam@json:string(Message)} |
            Data@2]
    ).

-file("src/jsonrpcx.gleam", 501).
-spec error_response_to_json(
    error_response(KIK),
    fun((KIK) -> gleam@json:json())
) -> gleam@json:json().
error_response_to_json(Error_response, Encode_data) ->
    {error_response, Jsonrpc, Id, Error} = Error_response,
    gleam@json:object(
        [{<<"jsonrpc"/utf8>>, version_to_json(Jsonrpc)},
            {<<"id"/utf8>>, id_to_json(Id)},
            {<<"error"/utf8>>, error_to_json(Error, Encode_data)}]
    ).

-file("src/jsonrpcx.gleam", 211).
-spec batch_response_item_to_json(batch_response_item(gleam@json:json())) -> gleam@json:json().
batch_response_item_to_json(Item) ->
    case Item of
        {batch_response_item_error_response, Msg} ->
            error_response_to_json(Msg, fun gleam@function:identity/1);

        {batch_response_item_response, Msg@1} ->
            response_to_json(Msg@1, fun gleam@function:identity/1)
    end.

-file("src/jsonrpcx.gleam", 167).
-spec batch_response_to_json(batch_response(gleam@json:json())) -> gleam@json:json().
batch_response_to_json(Batch_response) ->
    {batch_response, Batch} = Batch_response,
    gleam@json:array(Batch, fun batch_response_item_to_json/1).

-file("src/jsonrpcx.gleam", 556).
-spec error_decoder(gleam@dynamic@decode:decoder(KIS)) -> gleam@dynamic@decode:decoder(error_body(KIS)).
error_decoder(Data_decoder) ->
    gleam@dynamic@decode:field(
        <<"code"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Code) ->
            gleam@dynamic@decode:field(
                <<"message"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Message) ->
                    gleam@dynamic@decode:optional_field(
                        <<"data"/utf8>>,
                        none,
                        gleam@dynamic@decode:optional(Data_decoder),
                        fun(Data) ->
                            gleam@dynamic@decode:success(
                                {error_body, Code, Message, Data}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/jsonrpcx.gleam", 513).
-spec error_response_decoder(gleam@dynamic@decode:decoder(KIM)) -> gleam@dynamic@decode:decoder(error_response(KIM)).
error_response_decoder(Data_decoder) ->
    gleam@dynamic@decode:field(
        <<"jsonrpc"/utf8>>,
        version_decoder(),
        fun(Jsonrpc) ->
            gleam@dynamic@decode:field(
                <<"id"/utf8>>,
                id_decoder(),
                fun(Id) ->
                    gleam@dynamic@decode:field(
                        <<"error"/utf8>>,
                        error_decoder(Data_decoder),
                        fun(Error) ->
                            gleam@dynamic@decode:success(
                                {error_response, Jsonrpc, Id, Error}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/jsonrpcx.gleam", 219).
-spec batch_response_item_decoder() -> gleam@dynamic@decode:decoder(batch_response_item(gleam@dynamic:dynamic_())).
batch_response_item_decoder() ->
    Response = begin
        _pipe = response_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe,
            fun(Field@0) -> {batch_response_item_response, Field@0} end
        )
    end,
    Error_response = begin
        _pipe@1 = error_response_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe@1,
            fun(Field@0) -> {batch_response_item_error_response, Field@0} end
        )
    end,
    gleam@dynamic@decode:one_of(Response, [Error_response]).

-file("src/jsonrpcx.gleam", 163).
-spec batch_response_decoder() -> gleam@dynamic@decode:decoder(batch_response(gleam@dynamic:dynamic_())).
batch_response_decoder() ->
    _pipe = gleam@dynamic@decode:list(batch_response_item_decoder()),
    gleam@dynamic@decode:map(
        _pipe,
        fun(Field@0) -> {batch_response, Field@0} end
    ).

-file("src/jsonrpcx.gleam", 38).
-spec message_decoder() -> gleam@dynamic@decode:decoder(message()).
message_decoder() ->
    Request = begin
        _pipe = request_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe,
            fun(Field@0) -> {request_message, Field@0} end
        )
    end,
    Notification = begin
        _pipe@1 = notification_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe@1,
            fun(Field@0) -> {notification_message, Field@0} end
        )
    end,
    Response = begin
        _pipe@2 = response_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe@2,
            fun(Field@0) -> {response_message, Field@0} end
        )
    end,
    Error_response = begin
        _pipe@3 = error_response_decoder(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
        ),
        gleam@dynamic@decode:map(
            _pipe@3,
            fun(Field@0) -> {error_response_message, Field@0} end
        )
    end,
    Batch_request = begin
        _pipe@4 = batch_request_decoder(),
        gleam@dynamic@decode:map(
            _pipe@4,
            fun(Field@0) -> {batch_request_message, Field@0} end
        )
    end,
    Batch_response = begin
        _pipe@5 = batch_response_decoder(),
        gleam@dynamic@decode:map(
            _pipe@5,
            fun(Field@0) -> {batch_response_message, Field@0} end
        )
    end,
    gleam@dynamic@decode:one_of(
        Request,
        [Notification, Response, Error_response, Batch_request, Batch_response]
    ).

-file("src/jsonrpcx.gleam", 607).
?DOC(" Retrieve this error's code\n").
-spec error_code(json_rpc_error()) -> integer().
error_code(Error) ->
    erlang:element(2, Error).

-file("src/jsonrpcx.gleam", 612).
?DOC(" Retrieve this error's message\n").
-spec error_message(json_rpc_error()) -> binary().
error_message(Error) ->
    erlang:element(3, Error).

-file("src/jsonrpcx.gleam", 620).
?DOC(
    " An error defined for your specific application.\n"
    " The error code MUST not be within the range -32768 to -32000, otherwise\n"
    " `Error(Nil)` will be returned.\n"
    " The message SHOULD be limited to a concise single sentence.\n"
).
-spec application_error(integer(), binary()) -> {ok, json_rpc_error()} |
    {error, nil}.
application_error(Code, Message) ->
    case (Code >= -32768) andalso (Code =< -32000) of
        true ->
            {error, nil};

        false ->
            {ok, {json_rpc_error, Code, Message}}
    end.

-file("src/jsonrpcx.gleam", 633).
?DOC(
    " An error reserved for implementation-defined server-errors.\n"
    " The error code MUST be within the range -32099 to -32000, otherwise\n"
    " `Error(Nil)` will be returned.\n"
).
-spec server_error(integer()) -> {ok, json_rpc_error()} | {error, nil}.
server_error(Code) ->
    case (Code >= -32099) andalso (Code =< -32000) of
        true ->
            {ok, {json_rpc_error, Code, <<"Server error"/utf8>>}};

        false ->
            {error, nil}
    end.

-file("src/jsonrpcx.gleam", 656).
-spec param_error(gleam@dynamic@decode:decode_error()) -> boolean().
param_error(Error) ->
    gleam@list:first(erlang:element(4, Error)) =:= {ok, <<"params"/utf8>>}.

-file("src/jsonrpcx.gleam", 573).
-spec from_decode_errors(list(gleam@dynamic@decode:decode_error()), id()) -> error_response(any()).
from_decode_errors(Errors, Id) ->
    Params_error = gleam@list:all(
        Errors,
        fun(Error) ->
            gleam@list:first(erlang:element(4, Error)) =:= {ok,
                <<"params"/utf8>>}
        end
    ),
    case Params_error of
        true ->
            error_response(
                {json_rpc_error, -32602, <<"Invalid params"/utf8>>},
                Id
            );

        false ->
            error_response(
                {json_rpc_error, -32600, <<"Invalid Request"/utf8>>},
                Id
            )
    end.

-file("src/jsonrpcx.gleam", 563).
-spec error_response_from(gleam@json:decode_error(), id()) -> error_response(nothing()).
error_response_from(Json_error, Id) ->
    case Json_error of
        {unable_to_decode, Errors} ->
            from_decode_errors(Errors, Id);

        _ ->
            error_response({json_rpc_error, -32700, <<"Parse error"/utf8>>}, Id)
    end.

-file("src/jsonrpcx.gleam", 649).
?DOC(" Get the appropriate `JsonRpcError` based on a request's `decode.DecodeError`s.\n").
-spec decode_errors(list(gleam@dynamic@decode:decode_error())) -> json_rpc_error().
decode_errors(Errors) ->
    case gleam@list:all(Errors, fun param_error/1) of
        true ->
            {json_rpc_error, -32602, <<"Invalid params"/utf8>>};

        false ->
            {json_rpc_error, -32600, <<"Invalid Request"/utf8>>}
    end.

-file("src/jsonrpcx.gleam", 641).
?DOC(" Get the appropriate `JsonRpcError` based on a request's `json.DecodeError`.\n").
-spec json_error(gleam@json:decode_error()) -> json_rpc_error().
json_error(Error) ->
    case Error of
        {unable_to_decode, Errors} ->
            decode_errors(Errors);

        _ ->
            {json_rpc_error, -32700, <<"Parse error"/utf8>>}
    end.