-module(internal@foo_json).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/foo_json.gleam").
-export([to_json/1, to_string/1, get_decoder_foo/0, from_string/1]).

-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(false).

-file("src/internal/foo_json.gleam", 6).
?DOC(false).
-spec to_json(internal@foo:foo_json()) -> gleam@json:json().
to_json(T) ->
    gleam@json:object(
        [{<<"a_bool"/utf8>>, gleam@json:bool(erlang:element(2, T))},
            {<<"b_int"/utf8>>, gleam@json:int(erlang:element(3, T))},
            {<<"c_float"/utf8>>, gleam@json:float(erlang:element(4, T))},
            {<<"d_two_tuple"/utf8>>,
                gleam@json:preprocessed_array(
                    [gleam@json:int(erlang:element(1, erlang:element(5, T))),
                        gleam@json:string(
                            erlang:element(2, erlang:element(5, T))
                        )]
                )},
            {<<"e_option_int"/utf8>>,
                gleam@json:nullable(erlang:element(6, T), fun gleam@json:int/1)},
            {<<"f_string_list"/utf8>>,
                gleam@json:array(erlang:element(7, T), fun gleam@json:string/1)}]
    ).

-file("src/internal/foo_json.gleam", 23).
?DOC(false).
-spec to_string(internal@foo:foo_json()) -> binary().
to_string(T) ->
    gleam@json:to_string(to_json(T)).

-file("src/internal/foo_json.gleam", 27).
?DOC(false).
-spec get_decoder_foo() -> gleam@dynamic@decode:decoder(internal@foo:foo_json()).
get_decoder_foo() ->
    gleam@dynamic@decode:field(
        <<"a_bool"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_bool/1},
        fun(A_bool) ->
            gleam@dynamic@decode:field(
                <<"b_int"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_int/1},
                fun(B_int) ->
                    gleam@dynamic@decode:field(
                        <<"c_float"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_float/1},
                        fun(C_float) ->
                            gleam@dynamic@decode:field(
                                <<"d_two_tuple"/utf8>>,
                                begin
                                    gleam@dynamic@decode:field(
                                        0,
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_int/1},
                                        fun(El0) ->
                                            gleam@dynamic@decode:field(
                                                1,
                                                {decoder,
                                                    fun gleam@dynamic@decode:decode_string/1},
                                                fun(El1) ->
                                                    gleam@dynamic@decode:success(
                                                        {El0, El1}
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end,
                                fun(D_two_tuple) ->
                                    gleam@dynamic@decode:field(
                                        <<"e_option_int"/utf8>>,
                                        gleam@dynamic@decode:optional(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_int/1}
                                        ),
                                        fun(E_option_int) ->
                                            gleam@dynamic@decode:field(
                                                <<"f_string_list"/utf8>>,
                                                gleam@dynamic@decode:list(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_string/1}
                                                ),
                                                fun(F_string_list) ->
                                                    gleam@dynamic@decode:success(
                                                        {foo,
                                                            A_bool,
                                                            B_int,
                                                            C_float,
                                                            D_two_tuple,
                                                            E_option_int,
                                                            F_string_list}
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/internal/foo_json.gleam", 48).
?DOC(false).
-spec from_string(binary()) -> {ok, internal@foo:foo_json()} |
    {error, gleam@json:decode_error()}.
from_string(Json_str) ->
    gleam@json:parse(Json_str, get_decoder_foo()).