chrobot

-module(protocol@security).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([encode__certificate_id/1, decode__certificate_id/1, encode__mixed_content_type/1, decode__mixed_content_type/1, encode__security_state/1, decode__security_state/1, encode__security_state_explanation/1, decode__security_state_explanation/1, encode__certificate_error_action/1, decode__certificate_error_action/1, disable/1, enable/1, set_ignore_certificate_errors/2]).
-export_type([certificate_id/0, mixed_content_type/0, security_state/0, security_state_explanation/0, certificate_error_action/0]).

-type certificate_id() :: {certificate_id, integer()}.

-type mixed_content_type() :: mixed_content_type_blockable |
    mixed_content_type_optionally_blockable |
    mixed_content_type_none.

-type security_state() :: security_state_unknown |
    security_state_neutral |
    security_state_insecure |
    security_state_secure |
    security_state_info |
    security_state_insecure_broken.

-type security_state_explanation() :: {security_state_explanation,
        security_state(),
        binary(),
        binary(),
        binary(),
        mixed_content_type(),
        list(binary()),
        gleam@option:option(list(binary()))}.

-type certificate_error_action() :: certificate_error_action_continue |
    certificate_error_action_cancel.

-spec encode__certificate_id(certificate_id()) -> gleam@json:json().
encode__certificate_id(Value__) ->
    case Value__ of
        {certificate_id, Inner_value__} ->
            gleam@json:int(Inner_value__)
    end.

-spec decode__certificate_id(gleam@dynamic:dynamic_()) -> {ok, certificate_id()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__certificate_id(Value__) ->
    _pipe = Value__,
    (gleam@dynamic:decode1(
        fun(Field@0) -> {certificate_id, Field@0} end,
        fun gleam@dynamic:int/1
    ))(_pipe).

-spec encode__mixed_content_type(mixed_content_type()) -> gleam@json:json().
encode__mixed_content_type(Value__) ->
    _pipe = case Value__ of
        mixed_content_type_blockable ->
            <<"blockable"/utf8>>;

        mixed_content_type_optionally_blockable ->
            <<"optionally-blockable"/utf8>>;

        mixed_content_type_none ->
            <<"none"/utf8>>
    end,
    gleam@json:string(_pipe).

-spec decode__mixed_content_type(gleam@dynamic:dynamic_()) -> {ok,
        mixed_content_type()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__mixed_content_type(Value__) ->
    case gleam@dynamic:string(Value__) of
        {ok, <<"blockable"/utf8>>} ->
            {ok, mixed_content_type_blockable};

        {ok, <<"optionally-blockable"/utf8>>} ->
            {ok, mixed_content_type_optionally_blockable};

        {ok, <<"none"/utf8>>} ->
            {ok, mixed_content_type_none};

        {error, Error} ->
            {error, Error};

        {ok, Other} ->
            {error,
                [{decode_error,
                        <<"valid enum property"/utf8>>,
                        Other,
                        [<<"enum decoder"/utf8>>]}]}
    end.

-spec encode__security_state(security_state()) -> gleam@json:json().
encode__security_state(Value__) ->
    _pipe = case Value__ of
        security_state_unknown ->
            <<"unknown"/utf8>>;

        security_state_neutral ->
            <<"neutral"/utf8>>;

        security_state_insecure ->
            <<"insecure"/utf8>>;

        security_state_secure ->
            <<"secure"/utf8>>;

        security_state_info ->
            <<"info"/utf8>>;

        security_state_insecure_broken ->
            <<"insecure-broken"/utf8>>
    end,
    gleam@json:string(_pipe).

-spec decode__security_state(gleam@dynamic:dynamic_()) -> {ok, security_state()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__security_state(Value__) ->
    case gleam@dynamic:string(Value__) of
        {ok, <<"unknown"/utf8>>} ->
            {ok, security_state_unknown};

        {ok, <<"neutral"/utf8>>} ->
            {ok, security_state_neutral};

        {ok, <<"insecure"/utf8>>} ->
            {ok, security_state_insecure};

        {ok, <<"secure"/utf8>>} ->
            {ok, security_state_secure};

        {ok, <<"info"/utf8>>} ->
            {ok, security_state_info};

        {ok, <<"insecure-broken"/utf8>>} ->
            {ok, security_state_insecure_broken};

        {error, Error} ->
            {error, Error};

        {ok, Other} ->
            {error,
                [{decode_error,
                        <<"valid enum property"/utf8>>,
                        Other,
                        [<<"enum decoder"/utf8>>]}]}
    end.

-spec encode__security_state_explanation(security_state_explanation()) -> gleam@json:json().
encode__security_state_explanation(Value__) ->
    gleam@json:object(
        begin
            _pipe = [{<<"securityState"/utf8>>,
                    encode__security_state(erlang:element(2, Value__))},
                {<<"title"/utf8>>,
                    gleam@json:string(erlang:element(3, Value__))},
                {<<"summary"/utf8>>,
                    gleam@json:string(erlang:element(4, Value__))},
                {<<"description"/utf8>>,
                    gleam@json:string(erlang:element(5, Value__))},
                {<<"mixedContentType"/utf8>>,
                    encode__mixed_content_type(erlang:element(6, Value__))},
                {<<"certificate"/utf8>>,
                    gleam@json:array(
                        erlang:element(7, Value__),
                        fun gleam@json:string/1
                    )}],
            chrobot@internal@utils:add_optional(
                _pipe,
                erlang:element(8, Value__),
                fun(Inner_value__) ->
                    {<<"recommendations"/utf8>>,
                        gleam@json:array(Inner_value__, fun gleam@json:string/1)}
                end
            )
        end
    ).

-spec decode__security_state_explanation(gleam@dynamic:dynamic_()) -> {ok,
        security_state_explanation()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__security_state_explanation(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"securityState"/utf8>>,
            fun decode__security_state/1
        ))(Value__),
        fun(Security_state) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"title"/utf8>>,
                    fun gleam@dynamic:string/1
                ))(Value__),
                fun(Title) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"summary"/utf8>>,
                            fun gleam@dynamic:string/1
                        ))(Value__),
                        fun(Summary) ->
                            gleam@result:'try'(
                                (gleam@dynamic:field(
                                    <<"description"/utf8>>,
                                    fun gleam@dynamic:string/1
                                ))(Value__),
                                fun(Description) ->
                                    gleam@result:'try'(
                                        (gleam@dynamic:field(
                                            <<"mixedContentType"/utf8>>,
                                            fun decode__mixed_content_type/1
                                        ))(Value__),
                                        fun(Mixed_content_type) ->
                                            gleam@result:'try'(
                                                (gleam@dynamic:field(
                                                    <<"certificate"/utf8>>,
                                                    gleam@dynamic:list(
                                                        fun gleam@dynamic:string/1
                                                    )
                                                ))(Value__),
                                                fun(Certificate) ->
                                                    gleam@result:'try'(
                                                        (gleam@dynamic:optional_field(
                                                            <<"recommendations"/utf8>>,
                                                            gleam@dynamic:list(
                                                                fun gleam@dynamic:string/1
                                                            )
                                                        ))(Value__),
                                                        fun(Recommendations) ->
                                                            {ok,
                                                                {security_state_explanation,
                                                                    Security_state,
                                                                    Title,
                                                                    Summary,
                                                                    Description,
                                                                    Mixed_content_type,
                                                                    Certificate,
                                                                    Recommendations}}
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec encode__certificate_error_action(certificate_error_action()) -> gleam@json:json().
encode__certificate_error_action(Value__) ->
    _pipe = case Value__ of
        certificate_error_action_continue ->
            <<"continue"/utf8>>;

        certificate_error_action_cancel ->
            <<"cancel"/utf8>>
    end,
    gleam@json:string(_pipe).

-spec decode__certificate_error_action(gleam@dynamic:dynamic_()) -> {ok,
        certificate_error_action()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__certificate_error_action(Value__) ->
    case gleam@dynamic:string(Value__) of
        {ok, <<"continue"/utf8>>} ->
            {ok, certificate_error_action_continue};

        {ok, <<"cancel"/utf8>>} ->
            {ok, certificate_error_action_cancel};

        {error, Error} ->
            {error, Error};

        {ok, Other} ->
            {error,
                [{decode_error,
                        <<"valid enum property"/utf8>>,
                        Other,
                        [<<"enum decoder"/utf8>>]}]}
    end.

-spec disable(fun((binary(), gleam@option:option(any())) -> STF)) -> STF.
disable(Callback__) ->
    Callback__(<<"Security.disable"/utf8>>, none).

-spec enable(fun((binary(), gleam@option:option(any())) -> STJ)) -> STJ.
enable(Callback__) ->
    Callback__(<<"Security.enable"/utf8>>, none).

-spec set_ignore_certificate_errors(
    fun((binary(), gleam@option:option(gleam@json:json())) -> STN),
    boolean()
) -> STN.
set_ignore_certificate_errors(Callback__, Ignore) ->
    Callback__(
        <<"Security.setIgnoreCertificateErrors"/utf8>>,
        {some,
            gleam@json:object([{<<"ignore"/utf8>>, gleam@json:bool(Ignore)}])}
    ).