-module(sara@json).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/sara/json.gleam").
-export([json_serializable_builder/1]).
-export_type([generated_code/0, custom_encoder/0, custom_decoder/0, custom_zero_value/0, custom_codec/0, config/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 Serialization Code Generator\n"
    "\n"
    " This module provides a builder that automatically generates JSON encoding\n"
    " and decoding functions for Gleam custom types annotated with `//@json_encode`\n"
    " and/or `//@json_decode`.\n"
    "\n"
    " ## Basic Usage\n"
    "\n"
    " Annotate your types:\n"
    "\n"
    " ```gleam\n"
    " //@json_encode\n"
    " //@json_decode\n"
    " pub type User {\n"
    "   User(name: String, age: Int)\n"
    " }\n"
    " ```\n"
    "\n"
    " This generates a companion `*_json.gleam` file containing:\n"
    " - `pub fn user_to_json(user: User) -> json.Json`\n"
    " - `pub fn user_json_decoder() -> decode.Decoder(User)`\n"
    "\n"
    " ## Custom Codecs\n"
    "\n"
    " For types requiring special serialization logic, provide a `CustomCodec`:\n"
    "\n"
    " ```gleam\n"
    " json.json_serializable_builder(\n"
    "   json.Config([\n"
    "     json.CustomCodec(\n"
    "       type_name: \"Timestamp\",\n"
    "       module_path: \"gleam/time/timestamp\",\n"
    "       encode: fn(_, _, variable, _, _) {\n"
    "         json.GeneratedCode(\n"
    "           \"json.string(timestamp.to_rfc3339(\" <> variable <> \", calendar.utc_offset))\",\n"
    "           [\"gleam/time/calendar\", \"gleam/time/timestamp\"],\n"
    "           [],\n"
    "         )\n"
    "       },\n"
    "       decode: fn(_, _, _, _) {\n"
    "         json.GeneratedCode(\n"
    "           \"{\n"
    "   use date <- decode.then(decode.string)\n"
    "   case timestamp.parse_rfc3339(date) {\n"
    "     Ok(timestamp) -> decode.success(timestamp)\n"
    "     Error(_) -> decode.failure(timestamp.system_time(), \\\"Timestamp\\\")\n"
    "   }\n"
    " }\",\n"
    "           [\"gleam/time/calendar\", \"gleam/time/timestamp\"],\n"
    "           [],\n"
    "         )\n"
    "       },\n"
    "       zero: fn(_, _, _, _) {\n"
    "         Ok(json.GeneratedCode(\"timestamp.system_time()\", [\"gleam/time/timestamp\"], []))\n"
    "       },\n"
    "     ),\n"
    "   ]),\n"
    " )\n"
    " ```\n"
    "\n"
    " ## Codec Resolution Order\n"
    "\n"
    " 1. **Built-in types**: `Int`, `Float`, `Bool`, `String`, `List`, tuples\n"
    " 2. **Custom codecs**: Types registered via `CustomCodec` in config\n"
    " 3. **Annotated types**: Types with `//@json_encode` or `//@json_decode`\n"
    " 4. **Fallback**: Unresolved types become function parameters\n"
    "\n"
).

-type generated_code() :: {generated_code,
        binary(),
        list(binary()),
        list({binary(), binary()})}.

-type custom_encoder() :: {custom_encoder,
        binary(),
        binary(),
        fun((builder@context:build_context(), glance:type(), binary(), builder@module:module_(), builder@module:module_()) -> generated_code())}.

-type custom_decoder() :: {custom_decoder,
        binary(),
        binary(),
        fun((builder@context:build_context(), glance:type(), builder@module:module_(), builder@module:module_()) -> generated_code())}.

-type custom_zero_value() :: {custom_zero_value,
        binary(),
        binary(),
        fun((builder@context:build_context(), glance:type(), builder@module:module_(), builder@module:module_()) -> {ok,
                generated_code()} |
            {error, nil})}.

-type custom_codec() :: {custom_codec,
        binary(),
        binary(),
        fun((builder@context:build_context(), glance:type(), binary(), builder@module:module_(), builder@module:module_()) -> generated_code()),
        fun((builder@context:build_context(), glance:type(), builder@module:module_(), builder@module:module_()) -> generated_code()),
        fun((builder@context:build_context(), glance:type(), builder@module:module_(), builder@module:module_()) -> {ok,
                generated_code()} |
            {error, nil})}.

-type config() :: {config, list(custom_codec())}.

-file("src/sara/json.gleam", 1742).
-spec module_name_for_path(binary()) -> binary().
module_name_for_path(Name) ->
    case Name of
        <<""/utf8>> ->
            <<""/utf8>>;

        _ ->
            <<Name/binary, "."/utf8>>
    end.

-file("src/sara/json.gleam", 1682).
-spec virtual_type_definition(
    {ok, builder@inspect:type_definition()} | {error, nil},
    builder@context:build_context(),
    glance:type(),
    builder@module:module_()
) -> {ok, builder@inspect:type_definition()} | {error, nil}.
virtual_type_definition(Result, Ctx, Type_, Current_module) ->
    case Result of
        {ok, _} ->
            Result;

        {error, _} ->
            case Type_ of
                {named_type, _, Name, Module, _} ->
                    Is_prelude = builder@inspect:is_prelude_type(
                        Ctx,
                        Type_,
                        Current_module
                    ),
                    case {Name, Module, Is_prelude} of
                        {<<"Result"/utf8>>, none, true} ->
                            {ok,
                                {custom_type,
                                    {definition,
                                        [],
                                        {custom_type,
                                            {span, 0, 0},
                                            <<"Result"/utf8>>,
                                            public,
                                            false,
                                            [<<"a"/utf8>>, <<"b"/utf8>>],
                                            [{variant,
                                                    <<"Ok"/utf8>>,
                                                    [{unlabelled_variant_field,
                                                            {variable_type,
                                                                {span, 0, 0},
                                                                <<"a"/utf8>>}}],
                                                    []},
                                                {variant,
                                                    <<"Error"/utf8>>,
                                                    [{unlabelled_variant_field,
                                                            {variable_type,
                                                                {span, 0, 0},
                                                                <<"b"/utf8>>}}],
                                                    []}]}},
                                    {module,
                                        <<""/utf8>>,
                                        erlang:element(3, Current_module),
                                        erlang:element(4, Current_module),
                                        erlang:element(5, Current_module),
                                        erlang:element(6, Current_module),
                                        erlang:element(7, Current_module),
                                        erlang:element(8, Current_module),
                                        erlang:element(9, Current_module),
                                        erlang:element(10, Current_module),
                                        erlang:element(11, Current_module)}}};

                        {_, _, _} ->
                            Result
                    end;

                _ ->
                    Result
            end
    end.

-file("src/sara/json.gleam", 1589).
-spec get_zero_value_generic(
    config(),
    builder@context:build_context(),
    glance:type(),
    builder@module:module_(),
    builder@module:module_(),
    gleam@set:set(glance:variant())
) -> {ok, generated_code()} | {error, nil}.
get_zero_value_generic(
    Config,
    Ctx,
    Type_,
    Current_module,
    Original_module,
    Variant_path
) ->
    case virtual_type_definition(
        builder@inspect:find_type_definition(Ctx, Type_, Current_module),
        Ctx,
        Type_,
        Current_module
    ) of
        {ok, Type_defintion} ->
            case Type_defintion of
                {type_alias, Source, Module} ->
                    get_zero_value(
                        Config,
                        Ctx,
                        erlang:element(6, erlang:element(3, Source)),
                        Module,
                        Original_module,
                        Variant_path
                    );

                {custom_type, Source@1, Module@1} ->
                    Custom_zero_values = [{custom_zero_value,
                            <<"Option"/utf8>>,
                            <<"gleam/option"/utf8>>,
                            fun(_, _, _, _) ->
                                {ok,
                                    {generated_code,
                                        <<"option.None"/utf8>>,
                                        [<<"gleam/option"/utf8>>],
                                        []}}
                            end},
                        {custom_zero_value,
                            <<"Dict"/utf8>>,
                            <<"gleam/dict"/utf8>>,
                            fun(_, _, _, _) ->
                                {ok,
                                    {generated_code,
                                        <<"dict.new()"/utf8>>,
                                        [<<"gleam/dict"/utf8>>],
                                        []}}
                            end}],
                    Decoder = gleam@list:find_map(
                        lists:append(
                            Custom_zero_values,
                            gleam@list:map(
                                erlang:element(2, Config),
                                fun(Codec) ->
                                    {custom_zero_value,
                                        erlang:element(2, Codec),
                                        erlang:element(3, Codec),
                                        erlang:element(6, Codec)}
                                end
                            )
                        ),
                        fun(Custom_decoder) ->
                            case (erlang:element(3, erlang:element(3, Source@1))
                            =:= erlang:element(2, Custom_decoder))
                            andalso (erlang:element(4, Module@1) =:= erlang:element(
                                3,
                                Custom_decoder
                            )) of
                                true ->
                                    {ok, erlang:element(4, Custom_decoder)};

                                _ ->
                                    {error, nil}
                            end
                        end
                    ),
                    case Decoder of
                        {ok, Decode} ->
                            Decode(Ctx, Type_, Current_module, Original_module);

                        _ ->
                            case erlang:element(5, erlang:element(3, Source@1)) of
                                true ->
                                    {error, nil};

                                _ ->
                                    gleam@list:find_map(
                                        erlang:element(
                                            7,
                                            erlang:element(3, Source@1)
                                        ),
                                        fun(Variant) ->
                                            get_variant_zero_value(
                                                Config,
                                                Ctx,
                                                Variant,
                                                Module@1,
                                                Variant_path
                                            )
                                        end
                                    )
                            end
                    end
            end;

        {error, _} ->
            {error, nil}
    end.

-file("src/sara/json.gleam", 1528).
-spec get_zero_value(
    config(),
    builder@context:build_context(),
    glance:type(),
    builder@module:module_(),
    builder@module:module_(),
    gleam@set:set(glance:variant())
) -> {ok, generated_code()} | {error, nil}.
get_zero_value(
    Config,
    Ctx,
    Type_,
    Current_module,
    Original_module,
    Variant_path
) ->
    Is_prelude = builder@inspect:is_prelude_type(Ctx, Type_, Current_module),
    case Type_ of
        {named_type, _, Name, _, _} ->
            case {Name, Is_prelude} of
                {<<"Int"/utf8>>, true} ->
                    {ok, {generated_code, <<"0"/utf8>>, [], []}};

                {<<"Float"/utf8>>, true} ->
                    {ok, {generated_code, <<"0"/utf8>>, [], []}};

                {<<"Bool"/utf8>>, true} ->
                    {ok, {generated_code, <<"False"/utf8>>, [], []}};

                {<<"String"/utf8>>, true} ->
                    {ok, {generated_code, <<"\"\""/utf8>>, [], []}};

                {<<"List"/utf8>>, true} ->
                    {ok, {generated_code, <<"[]"/utf8>>, [], []}};

                {_, _} ->
                    get_zero_value_generic(
                        Config,
                        Ctx,
                        Type_,
                        Current_module,
                        Original_module,
                        Variant_path
                    )
            end;

        {tuple_type, _, Elements} ->
            Codes = gleam@list:try_map(
                Elements,
                fun(Element) ->
                    get_zero_value(
                        Config,
                        Ctx,
                        Element,
                        Current_module,
                        Original_module,
                        Variant_path
                    )
                end
            ),
            case Codes of
                {ok, Codes@1} ->
                    {ok,
                        {generated_code,
                            <<<<"#("/utf8,
                                    (begin
                                        _pipe = Codes@1,
                                        _pipe@1 = gleam@list:map(
                                            _pipe,
                                            fun(Code) ->
                                                erlang:element(2, Code)
                                            end
                                        ),
                                        gleam@string:join(_pipe@1, <<","/utf8>>)
                                    end)/binary>>/binary,
                                ")"/utf8>>,
                            begin
                                _pipe@2 = gleam@list:map(
                                    Codes@1,
                                    fun(Code@1) -> erlang:element(3, Code@1) end
                                ),
                                gleam@list:fold(
                                    _pipe@2,
                                    [],
                                    fun(Acc, Imports) ->
                                        lists:append(Acc, Imports)
                                    end
                                )
                            end,
                            begin
                                _pipe@3 = gleam@list:map(
                                    Codes@1,
                                    fun(Code@2) -> erlang:element(4, Code@2) end
                                ),
                                gleam@list:fold(
                                    _pipe@3,
                                    [],
                                    fun(Acc@1, Arguments) ->
                                        lists:append(Acc@1, Arguments)
                                    end
                                )
                            end}};

                {error, _} ->
                    {error, nil}
            end;

        _ ->
            {error, nil}
    end.

-file("src/sara/json.gleam", 1454).
-spec get_variant_zero_value(
    config(),
    builder@context:build_context(),
    glance:variant(),
    builder@module:module_(),
    gleam@set:set(glance:variant())
) -> {ok, generated_code()} | {error, nil}.
get_variant_zero_value(Config, Ctx, Variant, Module, Variant_path) ->
    gleam@bool:guard(
        gleam@set:contains(Variant_path, Variant),
        {error, nil},
        fun() ->
            Variant_path@1 = gleam@set:insert(Variant_path, Variant),
            Output = <<""/utf8>>,
            Fields = gleam@list:try_map(
                erlang:element(3, Variant),
                fun(Field) -> case erlang:element(2, Field) of
                        {variable_type, _, _} ->
                            {error, nil};

                        _ ->
                            Zero = get_zero_value(
                                Config,
                                Ctx,
                                erlang:element(2, Field),
                                Module,
                                Module,
                                Variant_path@1
                            ),
                            case Zero of
                                {ok, Zero@1} ->
                                    {ok, {generated_code, <<(case Field of
                                                    {labelled_variant_field,
                                                        _,
                                                        Label} ->
                                                        <<Label/binary,
                                                            ":"/utf8>>;

                                                    {unlabelled_variant_field,
                                                        _} ->
                                                        <<""/utf8>>
                                                end)/binary, (erlang:element(
                                                    2,
                                                    Zero@1
                                                ))/binary>>, erlang:element(
                                                3,
                                                Zero@1
                                            ), erlang:element(4, Zero@1)}};

                                {error, _} ->
                                    {error, nil}
                            end
                    end end
            ),
            case Fields of
                {ok, Fields@1} ->
                    Output@1 = <<<<<<Output/binary,
                                (module_name_for_path(erlang:element(2, Module)))/binary>>/binary,
                            (erlang:element(2, Variant))/binary>>/binary,
                        (case gleam@list:is_empty(Fields@1) of
                            false ->
                                Parameters = begin
                                    _pipe = gleam@list:map(
                                        Fields@1,
                                        fun(Field@1) ->
                                            erlang:element(2, Field@1)
                                        end
                                    ),
                                    gleam@string:join(_pipe, <<","/utf8>>)
                                end,
                                <<<<"("/utf8, Parameters/binary>>/binary,
                                    ")"/utf8>>;

                            _ ->
                                <<""/utf8>>
                        end)/binary>>,
                    {ok,
                        {generated_code,
                            Output@1,
                            begin
                                _pipe@1 = gleam@list:map(
                                    Fields@1,
                                    fun(Field@2) ->
                                        erlang:element(3, Field@2)
                                    end
                                ),
                                gleam@list:fold(
                                    _pipe@1,
                                    [],
                                    fun(Acc, Imports) ->
                                        lists:append(Acc, Imports)
                                    end
                                )
                            end,
                            begin
                                _pipe@2 = gleam@list:map(
                                    Fields@1,
                                    fun(Field@3) ->
                                        erlang:element(4, Field@3)
                                    end
                                ),
                                gleam@list:fold(
                                    _pipe@2,
                                    [],
                                    fun(Acc@1, Arguments) ->
                                        lists:append(Acc@1, Arguments)
                                    end
                                )
                            end}};

                {error, _} ->
                    {error, nil}
            end
        end
    ).

-file("src/sara/json.gleam", 228).
-spec get_generated_module_name(binary()) -> binary().
get_generated_module_name(Path) ->
    <<Path/binary, "_json"/utf8>>.

-file("src/sara/json.gleam", 1145).
-spec json_decode_type_generic(
    config(),
    builder@context:build_context(),
    glance:type(),
    binary(),
    builder@module:module_(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_decode_type_generic(
    Config,
    Ctx,
    Type_,
    Variable,
    Current_module,
    Original_module,
    Custom_type_path
) ->
    case virtual_type_definition(
        builder@inspect:find_type_definition(Ctx, Type_, Current_module),
        Ctx,
        Type_,
        Current_module
    ) of
        {ok, Type_defintion} ->
            case Type_defintion of
                {type_alias, Source, Module} ->
                    json_decode_type(
                        Config,
                        Ctx,
                        erlang:element(6, erlang:element(3, Source)),
                        Variable,
                        Module,
                        Original_module,
                        Custom_type_path
                    );

                {custom_type, Source@1, Module@1} ->
                    Custom_decoders = [{custom_decoder,
                            <<"Option"/utf8>>,
                            <<"gleam/option"/utf8>>,
                            fun(_, _, _, _) ->
                                Parameters@1 = case Type_ of
                                    {named_type, _, _, _, Parameters} -> Parameters;
                                    _assert_fail ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_decode_type_generic"/utf8>>,
                                                    line => 1180,
                                                    value => _assert_fail,
                                                    start => 33004,
                                                    'end' => 33056,
                                                    pattern_start => 33015,
                                                    pattern_end => 33048}
                                            )
                                end,
                                Type_@2 = case Parameters@1 of
                                    [Type_@1 | _] -> Type_@1;
                                    _assert_fail@1 ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_decode_type_generic"/utf8>>,
                                                    line => 1181,
                                                    value => _assert_fail@1,
                                                    start => 33073,
                                                    'end' => 33108,
                                                    pattern_start => 33084,
                                                    pattern_end => 33095}
                                            )
                                end,
                                Code = json_decode_type(
                                    Config,
                                    Ctx,
                                    Type_@2,
                                    Variable,
                                    Current_module,
                                    Original_module,
                                    Custom_type_path
                                ),
                                {generated_code,
                                    <<<<"decode.optional("/utf8,
                                            (erlang:element(2, Code))/binary>>/binary,
                                        ")"/utf8>>,
                                    erlang:element(3, Code),
                                    erlang:element(4, Code)}
                            end},
                        {custom_decoder,
                            <<"Dict"/utf8>>,
                            <<"gleam/dict"/utf8>>,
                            fun(_, _, _, _) ->
                                Parameters@3 = case Type_ of
                                    {named_type, _, _, _, Parameters@2} -> Parameters@2;
                                    _assert_fail@2 ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_decode_type_generic"/utf8>>,
                                                    line => 1204,
                                                    value => _assert_fail@2,
                                                    start => 33775,
                                                    'end' => 33827,
                                                    pattern_start => 33786,
                                                    pattern_end => 33819}
                                            )
                                end,
                                {Type_key@1, Type_value@1} = case Parameters@3 of
                                    [Type_key, Type_value | _] -> {
                                    Type_key,
                                        Type_value};
                                    _assert_fail@3 ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_decode_type_generic"/utf8>>,
                                                    line => 1205,
                                                    value => _assert_fail@3,
                                                    start => 33844,
                                                    'end' => 33894,
                                                    pattern_start => 33855,
                                                    pattern_end => 33881}
                                            )
                                end,
                                Code_key = begin
                                    Custom_key_decoder = begin
                                        Key_parameters = case Type_key@1 of
                                            {named_type, _, _, _, Parameters@4} ->
                                                Parameters@4;

                                            _ ->
                                                []
                                        end,
                                        Function = <<<<(justin:snake_case(
                                                    case Type_key@1 of
                                                        {named_type,
                                                            _,
                                                            Name,
                                                            _,
                                                            _} ->
                                                            Name;

                                                        _ ->
                                                            <<""/utf8>>
                                                    end
                                                ))/binary,
                                                (case Key_parameters of
                                                    [] ->
                                                        <<""/utf8>>;

                                                    _ ->
                                                        <<"_"/utf8,
                                                            (begin
                                                                _pipe = gleam@list:map(
                                                                    Key_parameters,
                                                                    fun(P) ->
                                                                        case P of
                                                                            {named_type,
                                                                                _,
                                                                                Name@1,
                                                                                _,
                                                                                _} ->
                                                                                justin:snake_case(
                                                                                    Name@1
                                                                                );

                                                                            _ ->
                                                                                <<""/utf8>>
                                                                        end
                                                                    end
                                                                ),
                                                                gleam@string:join(
                                                                    _pipe,
                                                                    <<"_"/utf8>>
                                                                )
                                                            end)/binary>>
                                                end)/binary>>/binary,
                                            "_key_decoder"/utf8>>,
                                        {generated_code,
                                            Function,
                                            [],
                                            [{Function, <<""/utf8>>}]}
                                    end,
                                    case Type_key@1 of
                                        {named_type, _, Name@2, _, _} ->
                                            case {Name@2,
                                                builder@inspect:is_prelude_type(
                                                    Ctx,
                                                    Type_key@1,
                                                    Current_module
                                                )} of
                                                {<<"String"/utf8>>, true} ->
                                                    {generated_code,
                                                        <<"decode.string"/utf8>>,
                                                        [],
                                                        []};

                                                {<<"Int"/utf8>>, true} ->
                                                    {generated_code,
                                                        <<"decode.then(decode.string, fn(s) { case int.parse(s) { Ok(v) -> decode.success(v) Error(_) -> decode.failure(0, \"Int\") } })"/utf8>>,
                                                        [<<"gleam/int"/utf8>>],
                                                        []};

                                                {<<"Float"/utf8>>, true} ->
                                                    {generated_code,
                                                        <<"decode.then(decode.string, fn(s) { case float.parse(s) { Ok(v) -> decode.success(v) Error(_) -> decode.failure(0.0, \"Float\") } })"/utf8>>,
                                                        [<<"gleam/float"/utf8>>],
                                                        []};

                                                {<<"Bool"/utf8>>, true} ->
                                                    {generated_code,
                                                        <<"decode.then(decode.string, fn(s) { case s { \"True\" -> decode.success(True) _ -> decode.success(False) } })"/utf8>>,
                                                        [],
                                                        []};

                                                {_, _} ->
                                                    Custom_key_decoder
                                            end;

                                        _ ->
                                            Custom_key_decoder
                                    end
                                end,
                                Code_value = json_decode_type(
                                    Config,
                                    Ctx,
                                    Type_value@1,
                                    Variable,
                                    Current_module,
                                    Original_module,
                                    Custom_type_path
                                ),
                                {generated_code,
                                    <<<<<<<<"decode.dict("/utf8,
                                                    (erlang:element(2, Code_key))/binary>>/binary,
                                                ","/utf8>>/binary,
                                            (erlang:element(2, Code_value))/binary>>/binary,
                                        ")"/utf8>>,
                                    lists:append(
                                        [<<"gleam/dict"/utf8>>],
                                        lists:append(
                                            erlang:element(3, Code_key),
                                            erlang:element(3, Code_value)
                                        )
                                    ),
                                    lists:append(
                                        erlang:element(4, Code_key),
                                        erlang:element(4, Code_value)
                                    )}
                            end}],
                    Decoder = gleam@list:find_map(
                        lists:append(
                            Custom_decoders,
                            gleam@list:map(
                                erlang:element(2, Config),
                                fun(Codec) ->
                                    {custom_decoder,
                                        erlang:element(2, Codec),
                                        erlang:element(3, Codec),
                                        erlang:element(5, Codec)}
                                end
                            )
                        ),
                        fun(Custom_decoder) ->
                            case (erlang:element(3, erlang:element(3, Source@1))
                            =:= erlang:element(2, Custom_decoder))
                            andalso (erlang:element(4, Module@1) =:= erlang:element(
                                3,
                                Custom_decoder
                            )) of
                                true ->
                                    {ok, erlang:element(4, Custom_decoder)};

                                _ ->
                                    {error, nil}
                            end
                        end
                    ),
                    case Decoder of
                        {ok, Decode} ->
                            Decode(Ctx, Type_, Current_module, Original_module);

                        _ ->
                            case builder@inspect:find_attribute(
                                Source@1,
                                <<"json_decode"/utf8>>
                            ) of
                                {ok, _} ->
                                    Other_arguments = case gleam@set:contains(
                                        Custom_type_path,
                                        erlang:element(3, Source@1)
                                    ) of
                                        false ->
                                            Custom_type_path@1 = gleam@set:insert(
                                                Custom_type_path,
                                                erlang:element(3, Source@1)
                                            ),
                                            erlang:element(
                                                4,
                                                json_decode_custom_type(
                                                    Config,
                                                    Ctx,
                                                    erlang:element(3, Source@1),
                                                    Module@1,
                                                    Custom_type_path@1
                                                )
                                            );

                                        _ ->
                                            []
                                    end,
                                    case erlang:element(4, Module@1) =:= erlang:element(
                                        4,
                                        Original_module
                                    ) of
                                        true ->
                                            {generated_code,
                                                <<<<<<(justin:snake_case(
                                                                erlang:element(
                                                                    3,
                                                                    erlang:element(
                                                                        3,
                                                                        Source@1
                                                                    )
                                                                )
                                                            ))/binary,
                                                            "_json_decoder("/utf8>>/binary,
                                                        (begin
                                                            _pipe@1 = gleam@list:map(
                                                                Other_arguments,
                                                                fun(Argument) ->
                                                                    erlang:element(
                                                                        1,
                                                                        Argument
                                                                    )
                                                                end
                                                            ),
                                                            _pipe@2 = gleam@list:unique(
                                                                _pipe@1
                                                            ),
                                                            gleam@string:join(
                                                                _pipe@2,
                                                                <<","/utf8>>
                                                            )
                                                        end)/binary>>/binary,
                                                    ")"/utf8>>,
                                                [],
                                                Other_arguments};

                                        false ->
                                            {generated_code,
                                                <<<<<<<<<<(get_generated_module_name(
                                                                        erlang:element(
                                                                            2,
                                                                            Module@1
                                                                        )
                                                                    ))/binary,
                                                                    "."/utf8>>/binary,
                                                                (justin:snake_case(
                                                                    erlang:element(
                                                                        3,
                                                                        erlang:element(
                                                                            3,
                                                                            Source@1
                                                                        )
                                                                    )
                                                                ))/binary>>/binary,
                                                            "_json_decoder("/utf8>>/binary,
                                                        (begin
                                                            _pipe@3 = gleam@list:map(
                                                                Other_arguments,
                                                                fun(Argument@1) ->
                                                                    erlang:element(
                                                                        1,
                                                                        Argument@1
                                                                    )
                                                                end
                                                            ),
                                                            _pipe@4 = gleam@list:unique(
                                                                _pipe@3
                                                            ),
                                                            gleam@string:join(
                                                                _pipe@4,
                                                                <<","/utf8>>
                                                            )
                                                        end)/binary>>/binary,
                                                    ")"/utf8>>,
                                                [get_generated_module_name(
                                                        erlang:element(
                                                            4,
                                                            Module@1
                                                        )
                                                    )],
                                                Other_arguments}
                                    end;

                                {error, _} ->
                                    Parameters@6 = case Type_ of
                                        {named_type, _, _, _, Parameters@5} ->
                                            Parameters@5;

                                        _ ->
                                            []
                                    end,
                                    Function@1 = <<<<(justin:snake_case(
                                                erlang:element(
                                                    3,
                                                    erlang:element(3, Source@1)
                                                )
                                            ))/binary,
                                            (case Parameters@6 of
                                                [] ->
                                                    <<""/utf8>>;

                                                _ ->
                                                    <<"_"/utf8,
                                                        (begin
                                                            _pipe@5 = gleam@list:map(
                                                                Parameters@6,
                                                                fun(Parameter) ->
                                                                    case Parameter of
                                                                        {named_type,
                                                                            _,
                                                                            Name@3,
                                                                            _,
                                                                            _} ->
                                                                            justin:snake_case(
                                                                                Name@3
                                                                            );

                                                                        _ ->
                                                                            <<""/utf8>>
                                                                    end
                                                                end
                                                            ),
                                                            gleam@string:join(
                                                                _pipe@5,
                                                                <<"_"/utf8>>
                                                            )
                                                        end)/binary>>
                                            end)/binary>>/binary,
                                        "_json_decoder"/utf8>>,
                                    {generated_code,
                                        <<Function@1/binary, "()"/utf8>>,
                                        [erlang:element(4, Module@1)],
                                        [{Function@1,
                                                <<<<<<<<"fn() -> decode.Decoder("/utf8,
                                                                (module_name_for_path(
                                                                    erlang:element(
                                                                        2,
                                                                        Module@1
                                                                    )
                                                                ))/binary>>/binary,
                                                            (erlang:element(
                                                                3,
                                                                erlang:element(
                                                                    3,
                                                                    Source@1
                                                                )
                                                            ))/binary>>/binary,
                                                        (case Parameters@6 of
                                                            [] ->
                                                                <<""/utf8>>;

                                                            _ ->
                                                                <<<<"("/utf8,
                                                                        (begin
                                                                            _pipe@6 = gleam@list:map(
                                                                                Parameters@6,
                                                                                fun(
                                                                                    Parameter@1
                                                                                ) ->
                                                                                    case Parameter@1 of
                                                                                        {named_type,
                                                                                            _,
                                                                                            Name@4,
                                                                                            _,
                                                                                            _} ->
                                                                                            Name@4;

                                                                                        _ ->
                                                                                            <<""/utf8>>
                                                                                    end
                                                                                end
                                                                            ),
                                                                            gleam@string:join(
                                                                                _pipe@6,
                                                                                <<","/utf8>>
                                                                            )
                                                                        end)/binary>>/binary,
                                                                    ")"/utf8>>
                                                        end)/binary>>/binary,
                                                    ")"/utf8>>}]}
                            end
                    end
            end;

        {error, _} ->
            Parameters@8 = case Type_ of
                {named_type, _, _, _, Parameters@7} ->
                    Parameters@7;

                _ ->
                    []
            end,
            Function@2 = <<<<(justin:snake_case(case Type_ of
                            {named_type, _, Name@5, _, _} ->
                                Name@5;

                            _ ->
                                <<""/utf8>>
                        end))/binary, (case Parameters@8 of
                        [] ->
                            case Type_ of
                                {function_type, _, _, _} ->
                                    Variable;

                                _ ->
                                    <<""/utf8>>
                            end;

                        _ ->
                            <<"_"/utf8,
                                (begin
                                    _pipe@7 = gleam@list:map(
                                        Parameters@8,
                                        fun(Parameter@2) -> case Parameter@2 of
                                                {named_type, _, Name@6, _, _} ->
                                                    justin:snake_case(Name@6);

                                                _ ->
                                                    <<""/utf8>>
                                            end end
                                    ),
                                    gleam@string:join(_pipe@7, <<"_"/utf8>>)
                                end)/binary>>
                    end)/binary>>/binary, "_json_decoder"/utf8>>,
            {generated_code,
                <<Function@2/binary, "()"/utf8>>,
                [],
                [{Function@2, <<""/utf8>>}]}
    end.

-file("src/sara/json.gleam", 1039).
-spec json_decode_type(
    config(),
    builder@context:build_context(),
    glance:type(),
    binary(),
    builder@module:module_(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_decode_type(
    Config,
    Ctx,
    Type_,
    Variable,
    Current_module,
    Original_module,
    Custom_type_path
) ->
    Is_prelude = builder@inspect:is_prelude_type(Ctx, Type_, Current_module),
    case Type_ of
        {named_type, _, Name, _, Parameters} ->
            case {Name, Is_prelude} of
                {<<"Int"/utf8>>, true} ->
                    {generated_code, <<"decode.int"/utf8>>, [], []};

                {<<"Float"/utf8>>, true} ->
                    {generated_code,
                        <<"decode.one_of(decode.float, [decode.map(decode.int, int.to_float)])"/utf8>>,
                        [<<"gleam/int"/utf8>>],
                        []};

                {<<"Bool"/utf8>>, true} ->
                    {generated_code, <<"decode.bool"/utf8>>, [], []};

                {<<"String"/utf8>>, true} ->
                    {generated_code, <<"decode.string"/utf8>>, [], []};

                {<<"List"/utf8>>, true} ->
                    Type_@2 = case Parameters of
                        [Type_@1 | _] -> Type_@1;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"sara/json"/utf8>>,
                                        function => <<"json_decode_type"/utf8>>,
                                        line => 1063,
                                        value => _assert_fail,
                                        start => 30005,
                                        'end' => 30040,
                                        pattern_start => 30016,
                                        pattern_end => 30027})
                    end,
                    List_decoder = json_decode_type(
                        Config,
                        Ctx,
                        Type_@2,
                        Variable,
                        Current_module,
                        Original_module,
                        Custom_type_path
                    ),
                    {generated_code,
                        <<<<"decode.list("/utf8,
                                ((erlang:element(2, List_decoder)))/binary>>/binary,
                            ")"/utf8>>,
                        erlang:element(3, List_decoder),
                        erlang:element(4, List_decoder)};

                {_, _} ->
                    json_decode_type_generic(
                        Config,
                        Ctx,
                        Type_,
                        Variable,
                        Current_module,
                        Original_module,
                        Custom_type_path
                    )
            end;

        {tuple_type, _, Elements} ->
            Codes = gleam@list:map(
                Elements,
                fun(Element) ->
                    json_decode_type(
                        Config,
                        Ctx,
                        Element,
                        Variable,
                        Current_module,
                        Original_module,
                        Custom_type_path
                    )
                end
            ),
            {generated_code,
                <<<<<<<<<<"{"/utf8,
                                    (begin
                                        _pipe = Codes,
                                        _pipe@1 = gleam@list:index_map(
                                            _pipe,
                                            fun(Code, I) ->
                                                <<<<<<<<<<<<"use "/utf8,
                                                                        ((<<"field"/utf8,
                                                                            (erlang:integer_to_binary(
                                                                                I
                                                                            ))/binary>>))/binary>>/binary,
                                                                    " <- decode.field("/utf8>>/binary,
                                                                (erlang:integer_to_binary(
                                                                    I
                                                                ))/binary>>/binary,
                                                            ","/utf8>>/binary,
                                                        (erlang:element(2, Code))/binary>>/binary,
                                                    ")"/utf8>>
                                            end
                                        ),
                                        gleam@string:join(
                                            _pipe@1,
                                            <<"\n"/utf8>>
                                        )
                                    end)/binary>>/binary,
                                "decode.success(#("/utf8>>/binary,
                            (begin
                                _pipe@2 = Codes,
                                _pipe@3 = gleam@list:index_map(
                                    _pipe@2,
                                    fun(_, I@1) ->
                                        <<"field"/utf8,
                                            (erlang:integer_to_binary(I@1))/binary>>
                                    end
                                ),
                                gleam@string:join(_pipe@3, <<","/utf8>>)
                            end)/binary>>/binary,
                        "))"/utf8>>/binary,
                    "}"/utf8>>,
                begin
                    _pipe@4 = gleam@list:map(
                        Codes,
                        fun(Code@1) -> erlang:element(3, Code@1) end
                    ),
                    gleam@list:fold(
                        _pipe@4,
                        [],
                        fun(Acc, Imports) -> lists:append(Acc, Imports) end
                    )
                end,
                begin
                    _pipe@5 = gleam@list:map(
                        Codes,
                        fun(Code@2) -> erlang:element(4, Code@2) end
                    ),
                    gleam@list:fold(
                        _pipe@5,
                        [],
                        fun(Acc@1, Arguments) ->
                            lists:append(Acc@1, Arguments)
                        end
                    )
                end};

        {function_type, _, _, _} ->
            json_decode_type_generic(
                Config,
                Ctx,
                Type_,
                Variable,
                Current_module,
                Original_module,
                Custom_type_path
            );

        _ ->
            {generated_code, <<"todo"/utf8>>, [], []}
    end.

-file("src/sara/json.gleam", 950).
-spec json_decode_variant(
    config(),
    builder@context:build_context(),
    glance:variant(),
    boolean(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_decode_variant(
    Config,
    Ctx,
    Variant,
    Has_variant_type,
    Module,
    Custom_type_path
) ->
    Output = <<""/utf8>>,
    Fields = gleam@list:index_map(
        erlang:element(3, Variant),
        fun(Field, I) ->
            Variable = case Field of
                {labelled_variant_field, _, Label} ->
                    Label;

                {unlabelled_variant_field, _} ->
                    <<"field"/utf8, (erlang:integer_to_binary(I))/binary>>
            end,
            case erlang:element(2, Field) of
                {variable_type, _, _} ->
                    {generated_code,
                        <<"todo as \"cant handle generic\""/utf8>>,
                        [],
                        []};

                _ ->
                    {generated_code, Code, Imports, Arguments} = json_decode_type(
                        Config,
                        Ctx,
                        erlang:element(2, Field),
                        Variable,
                        Module,
                        Module,
                        Custom_type_path
                    ),
                    {generated_code,
                        <<<<<<<<<<<<"use "/utf8, Variable/binary>>/binary,
                                            "<- decode.field(\""/utf8>>/binary,
                                        Variable/binary>>/binary,
                                    "\","/utf8>>/binary,
                                Code/binary>>/binary,
                            ")\n"/utf8>>,
                        Imports,
                        Arguments}
            end
        end
    ),
    Output@1 = <<Output/binary,
        (begin
            _pipe = Fields,
            _pipe@1 = gleam@list:map(
                _pipe,
                fun(Field@1) -> erlang:element(2, Field@1) end
            ),
            gleam@string:join(_pipe@1, <<""/utf8>>)
        end)/binary>>,
    Output@2 = <<<<<<<<<<Output@1/binary, "decode.success("/utf8>>/binary,
                    (module_name_for_path(erlang:element(2, Module)))/binary>>/binary,
                (erlang:element(2, Variant))/binary>>/binary,
            (case gleam@list:is_empty(erlang:element(3, Variant)) of
                false ->
                    Parameters = begin
                        _pipe@2 = gleam@list:index_map(
                            erlang:element(3, Variant),
                            fun(Field@2, I@1) -> case Field@2 of
                                    {labelled_variant_field, _, Label@1} ->
                                        <<Label@1/binary, ":"/utf8>>;

                                    {unlabelled_variant_field, _} ->
                                        <<"field"/utf8,
                                            (erlang:integer_to_binary(I@1))/binary>>
                                end end
                        ),
                        gleam@string:join(_pipe@2, <<","/utf8>>)
                    end,
                    <<<<"("/utf8, Parameters/binary>>/binary, ")"/utf8>>;

                _ ->
                    <<""/utf8>>
            end)/binary>>/binary,
        ")"/utf8>>,
    {generated_code, case Has_variant_type of
            true ->
                <<<<<<<<"\""/utf8,
                                (justin:snake_case(erlang:element(2, Variant)))/binary>>/binary,
                            "\"-> {"/utf8>>/binary,
                        Output@2/binary>>/binary,
                    "}"/utf8>>;

            false ->
                Output@2
        end, begin
            _pipe@3 = gleam@list:map(
                Fields,
                fun(Field@3) -> erlang:element(3, Field@3) end
            ),
            gleam@list:fold(
                _pipe@3,
                [],
                fun(Acc, Imports@1) -> lists:append(Acc, Imports@1) end
            )
        end, begin
            _pipe@4 = gleam@list:map(
                Fields,
                fun(Field@4) -> erlang:element(4, Field@4) end
            ),
            gleam@list:fold(
                _pipe@4,
                [],
                fun(Acc@1, Arguments@1) -> lists:append(Acc@1, Arguments@1) end
            )
        end}.

-file("src/sara/json.gleam", 865).
-spec json_decode_custom_type(
    config(),
    builder@context:build_context(),
    glance:custom_type(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_decode_custom_type(Config, Ctx, Custom_type, Module, Custom_type_path) ->
    Has_variant_type = case erlang:element(7, Custom_type) of
        [_] ->
            false;

        _ ->
            true
    end,
    Variants = gleam@list:map(
        erlang:element(7, Custom_type),
        fun(Variant) ->
            json_decode_variant(
                Config,
                Ctx,
                Variant,
                Has_variant_type,
                Module,
                Custom_type_path
            )
        end
    ),
    Output@5 = case Has_variant_type of
        true ->
            Output = <<"use variant <- decode.field(\"type\", decode.string)\n"/utf8>>,
            Output@1 = <<Output/binary, "case variant {\n"/utf8>>,
            Output@2 = <<Output@1/binary,
                (begin
                    _pipe = Variants,
                    _pipe@1 = gleam@list:map(
                        _pipe,
                        fun(Variant@1) -> erlang:element(2, Variant@1) end
                    ),
                    gleam@string:join(_pipe@1, <<"\n"/utf8>>)
                end)/binary>>,
            Zero_value = gleam@list:find_map(
                erlang:element(7, Custom_type),
                fun(Variant@2) ->
                    get_variant_zero_value(
                        Config,
                        Ctx,
                        Variant@2,
                        Module,
                        gleam@set:new()
                    )
                end
            ),
            Output@3 = <<<<<<<<<<Output@2/binary, "_ -> decode.failure("/utf8>>/binary,
                            (case Zero_value of
                                {ok, Zero_value@1} ->
                                    erlang:element(2, Zero_value@1);

                                _ ->
                                    <<(justin:snake_case(
                                            erlang:element(3, Custom_type)
                                        ))/binary,
                                        "_zero_value"/utf8>>
                            end)/binary>>/binary,
                        ", \""/utf8>>/binary,
                    (erlang:element(3, Custom_type))/binary>>/binary,
                "\" )\n"/utf8>>,
            Output@4 = <<Output@3/binary, "}\n"/utf8>>,
            {generated_code, Output@4, [], case Zero_value of
                    {ok, _} ->
                        [];

                    _ ->
                        [{<<(justin:snake_case(erlang:element(3, Custom_type)))/binary,
                                    "_zero_value"/utf8>>,
                                <<(module_name_for_path(
                                        erlang:element(2, Module)
                                    ))/binary,
                                    (erlang:element(3, Custom_type))/binary>>}]
                end};

        false ->
            {generated_code,
                begin
                    _pipe@2 = Variants,
                    _pipe@3 = gleam@list:map(
                        _pipe@2,
                        fun(Variant@3) -> erlang:element(2, Variant@3) end
                    ),
                    gleam@string:join(_pipe@3, <<"\n"/utf8>>)
                end,
                [],
                []}
    end,
    {generated_code,
        erlang:element(2, Output@5),
        begin
            _pipe@4 = gleam@list:map(
                Variants,
                fun(Variant@4) -> erlang:element(3, Variant@4) end
            ),
            _pipe@5 = gleam@list:fold(
                _pipe@4,
                [],
                fun(Acc, Imports) -> lists:append(Acc, Imports) end
            ),
            lists:append(_pipe@5, erlang:element(3, Output@5))
        end,
        begin
            _pipe@6 = gleam@list:map(
                Variants,
                fun(Variant@5) -> erlang:element(4, Variant@5) end
            ),
            _pipe@7 = gleam@list:fold(
                _pipe@6,
                [],
                fun(Acc@1, Arguments) -> lists:append(Acc@1, Arguments) end
            ),
            lists:append(_pipe@7, erlang:element(4, Output@5))
        end}.

-file("src/sara/json.gleam", 832).
-spec json_create_custom_type_decode_function(
    config(),
    builder@context:build_context(),
    glance:custom_type(),
    builder@module:module_()
) -> generated_code().
json_create_custom_type_decode_function(Config, Ctx, Custom_type, Module) ->
    X = justin:snake_case(erlang:element(3, Custom_type)),
    {generated_code, Code, Imports, Arguments} = json_decode_custom_type(
        Config,
        Ctx,
        Custom_type,
        Module,
        gleam@set:new()
    ),
    Output = <<<<<<<<<<<<<<"pub fn "/utf8, X/binary>>/binary,
                            "_json_decoder("/utf8>>/binary,
                        (begin
                            _pipe = gleam@list:map(
                                Arguments,
                                fun(Argument) ->
                                    case erlang:element(2, Argument) of
                                        <<""/utf8>> ->
                                            erlang:element(1, Argument);

                                        _ ->
                                            <<<<(erlang:element(1, Argument))/binary,
                                                    ":"/utf8>>/binary,
                                                (erlang:element(2, Argument))/binary>>
                                    end
                                end
                            ),
                            _pipe@1 = gleam@list:unique(_pipe),
                            gleam@string:join(_pipe@1, <<","/utf8>>)
                        end)/binary>>/binary,
                    ") -> decode.Decoder("/utf8>>/binary,
                (module_name_for_path(erlang:element(2, Module)))/binary>>/binary,
            (erlang:element(3, Custom_type))/binary>>/binary,
        ") {\n"/utf8>>,
    Output@1 = <<Output/binary, Code/binary>>,
    Output@2 = <<Output@1/binary, "}"/utf8>>,
    {generated_code, Output@2, Imports, Arguments}.

-file("src/sara/json.gleam", 496).
-spec json_encode_type_generic(
    config(),
    builder@context:build_context(),
    glance:type(),
    binary(),
    builder@module:module_(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_encode_type_generic(
    Config,
    Ctx,
    Type_,
    Variable,
    Current_module,
    Original_module,
    Custom_type_path
) ->
    case virtual_type_definition(
        builder@inspect:find_type_definition(Ctx, Type_, Current_module),
        Ctx,
        Type_,
        Current_module
    ) of
        {ok, Type_defintion} ->
            case Type_defintion of
                {type_alias, Source, Module} ->
                    json_encode_type(
                        Config,
                        Ctx,
                        erlang:element(6, erlang:element(3, Source)),
                        Variable,
                        Module,
                        Original_module,
                        Custom_type_path
                    );

                {custom_type, Source@1, Module@1} ->
                    Custom_encoders = [{custom_encoder,
                            <<"Option"/utf8>>,
                            <<"gleam/option"/utf8>>,
                            fun(_, _, Variable@1, _, _) ->
                                Parameters@1 = case Type_ of
                                    {named_type, _, _, _, Parameters} -> Parameters;
                                    _assert_fail ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_encode_type_generic"/utf8>>,
                                                    line => 531,
                                                    value => _assert_fail,
                                                    start => 13855,
                                                    'end' => 13907,
                                                    pattern_start => 13866,
                                                    pattern_end => 13899}
                                            )
                                end,
                                Type_@2 = case Parameters@1 of
                                    [Type_@1 | _] -> Type_@1;
                                    _assert_fail@1 ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_encode_type_generic"/utf8>>,
                                                    line => 532,
                                                    value => _assert_fail@1,
                                                    start => 13924,
                                                    'end' => 13959,
                                                    pattern_start => 13935,
                                                    pattern_end => 13946}
                                            )
                                end,
                                Code = json_encode_type(
                                    Config,
                                    Ctx,
                                    Type_@2,
                                    <<"x"/utf8>>,
                                    Current_module,
                                    Original_module,
                                    Custom_type_path
                                ),
                                {generated_code,
                                    <<<<<<<<<<"case "/utf8, Variable@1/binary>>/binary,
                                                    "{option.None->json.null()"/utf8>>/binary,
                                                "option.Some(x)->"/utf8>>/binary,
                                            (erlang:element(2, Code))/binary>>/binary,
                                        "}"/utf8>>,
                                    lists:append(
                                        [<<"gleam/option"/utf8>>],
                                        erlang:element(3, Code)
                                    ),
                                    erlang:element(4, Code)}
                            end},
                        {custom_encoder,
                            <<"Dict"/utf8>>,
                            <<"gleam/dict"/utf8>>,
                            fun(_, _, Variable@2, _, _) ->
                                Parameters@3 = case Type_ of
                                    {named_type, _, _, _, Parameters@2} -> Parameters@2;
                                    _assert_fail@2 ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_encode_type_generic"/utf8>>,
                                                    line => 560,
                                                    value => _assert_fail@2,
                                                    start => 14816,
                                                    'end' => 14868,
                                                    pattern_start => 14827,
                                                    pattern_end => 14860}
                                            )
                                end,
                                {Type_key@1, Type_value@1} = case Parameters@3 of
                                    [Type_key, Type_value | _] -> {
                                    Type_key,
                                        Type_value};
                                    _assert_fail@3 ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"sara/json"/utf8>>,
                                                    function => <<"json_encode_type_generic"/utf8>>,
                                                    line => 561,
                                                    value => _assert_fail@3,
                                                    start => 14885,
                                                    'end' => 14935,
                                                    pattern_start => 14896,
                                                    pattern_end => 14922}
                                            )
                                end,
                                Custom_stringify = begin
                                    Parameters@5 = case Type_key@1 of
                                        {named_type, _, _, _, Parameters@4} ->
                                            Parameters@4;

                                        _ ->
                                            []
                                    end,
                                    Function = <<<<(justin:snake_case(
                                                case Type_key@1 of
                                                    {named_type, _, Name, _, _} ->
                                                        Name;

                                                    _ ->
                                                        <<""/utf8>>
                                                end
                                            ))/binary,
                                            (case Parameters@5 of
                                                [] ->
                                                    case Type_key@1 of
                                                        {function_type, _, _, _} ->
                                                            Variable@2;

                                                        _ ->
                                                            <<""/utf8>>
                                                    end;

                                                _ ->
                                                    <<"_"/utf8,
                                                        (begin
                                                            _pipe = gleam@list:map(
                                                                Parameters@5,
                                                                fun(Parameter) ->
                                                                    case Parameter of
                                                                        {named_type,
                                                                            _,
                                                                            Name@1,
                                                                            _,
                                                                            _} ->
                                                                            justin:snake_case(
                                                                                Name@1
                                                                            );

                                                                        _ ->
                                                                            <<""/utf8>>
                                                                    end
                                                                end
                                                            ),
                                                            gleam@string:join(
                                                                _pipe,
                                                                <<"_"/utf8>>
                                                            )
                                                        end)/binary>>
                                            end)/binary>>/binary,
                                        "_stringify"/utf8>>,
                                    {generated_code,
                                        <<<<<<Function/binary, "("/utf8>>/binary,
                                                Variable@2/binary>>/binary,
                                            ")"/utf8>>,
                                        [],
                                        [{Function, <<""/utf8>>}]}
                                end,
                                Code_key = case Type_key@1 of
                                    {named_type, _, Name@2, _, _} ->
                                        case {Name@2,
                                            builder@inspect:is_prelude_type(
                                                Ctx,
                                                Type_key@1,
                                                Current_module
                                            )} of
                                            {<<"Int"/utf8>>, true} ->
                                                {generated_code,
                                                    <<"fn (x) {int.to_string(x)}"/utf8>>,
                                                    [<<"gleam/int"/utf8>>],
                                                    []};

                                            {<<"Float"/utf8>>, true} ->
                                                {generated_code,
                                                    <<"fn (x) {float.to_string(x)}"/utf8>>,
                                                    [<<"gleam/float"/utf8>>],
                                                    []};

                                            {<<"Bool"/utf8>>, true} ->
                                                {generated_code,
                                                    <<"fn (x) {bool.to_string(x)}"/utf8>>,
                                                    [<<"gleam/bool"/utf8>>],
                                                    []};

                                            {<<"String"/utf8>>, true} ->
                                                {generated_code,
                                                    <<"fn (x) {x}"/utf8>>,
                                                    [],
                                                    []};

                                            {_, _} ->
                                                Custom_stringify
                                        end;

                                    _ ->
                                        Custom_stringify
                                end,
                                Code_value = json_encode_type(
                                    Config,
                                    Ctx,
                                    Type_value@1,
                                    <<"x"/utf8>>,
                                    Current_module,
                                    Original_module,
                                    Custom_type_path
                                ),
                                {generated_code,
                                    <<<<<<<<<<<<"json.dict("/utf8,
                                                            Variable@2/binary>>/binary,
                                                        ","/utf8>>/binary,
                                                    (erlang:element(2, Code_key))/binary>>/binary,
                                                ",fn (x) {"/utf8>>/binary,
                                            (erlang:element(2, Code_value))/binary>>/binary,
                                        "})"/utf8>>,
                                    lists:append(
                                        [<<"gleam/dict"/utf8>>],
                                        lists:append(
                                            erlang:element(3, Code_key),
                                            erlang:element(3, Code_value)
                                        )
                                    ),
                                    lists:append(
                                        erlang:element(4, Code_key),
                                        erlang:element(4, Code_value)
                                    )}
                            end}],
                    Encoder = gleam@list:find_map(
                        lists:append(
                            Custom_encoders,
                            gleam@list:map(
                                erlang:element(2, Config),
                                fun(Codec) ->
                                    {custom_encoder,
                                        erlang:element(2, Codec),
                                        erlang:element(3, Codec),
                                        erlang:element(4, Codec)}
                                end
                            )
                        ),
                        fun(Custom_encoder) ->
                            case (erlang:element(3, erlang:element(3, Source@1))
                            =:= erlang:element(2, Custom_encoder))
                            andalso (erlang:element(4, Module@1) =:= erlang:element(
                                3,
                                Custom_encoder
                            )) of
                                true ->
                                    {ok, erlang:element(4, Custom_encoder)};

                                _ ->
                                    {error, nil}
                            end
                        end
                    ),
                    case Encoder of
                        {ok, Encode} ->
                            Encode(
                                Ctx,
                                Type_,
                                Variable,
                                Current_module,
                                Original_module
                            );

                        _ ->
                            case builder@inspect:find_attribute(
                                Source@1,
                                <<"json_encode"/utf8>>
                            ) of
                                {ok, _} ->
                                    Other_arguments = case gleam@set:contains(
                                        Custom_type_path,
                                        erlang:element(3, Source@1)
                                    ) of
                                        false ->
                                            Custom_type_path@1 = gleam@set:insert(
                                                Custom_type_path,
                                                erlang:element(3, Source@1)
                                            ),
                                            erlang:element(
                                                4,
                                                json_encode_custom_type(
                                                    Config,
                                                    Ctx,
                                                    erlang:element(3, Source@1),
                                                    <<""/utf8>>,
                                                    Module@1,
                                                    Custom_type_path@1
                                                )
                                            );

                                        _ ->
                                            []
                                    end,
                                    case erlang:element(4, Module@1) =:= erlang:element(
                                        4,
                                        Original_module
                                    ) of
                                        true ->
                                            {generated_code,
                                                <<<<<<(justin:snake_case(
                                                                erlang:element(
                                                                    3,
                                                                    erlang:element(
                                                                        3,
                                                                        Source@1
                                                                    )
                                                                )
                                                            ))/binary,
                                                            "_to_json("/utf8>>/binary,
                                                        (begin
                                                            _pipe@1 = [Variable |
                                                                gleam@list:map(
                                                                    Other_arguments,
                                                                    fun(
                                                                        Argument
                                                                    ) ->
                                                                        erlang:element(
                                                                            1,
                                                                            Argument
                                                                        )
                                                                    end
                                                                )],
                                                            _pipe@2 = gleam@list:unique(
                                                                _pipe@1
                                                            ),
                                                            gleam@string:join(
                                                                _pipe@2,
                                                                <<","/utf8>>
                                                            )
                                                        end)/binary>>/binary,
                                                    ")"/utf8>>,
                                                [],
                                                Other_arguments};

                                        false ->
                                            {generated_code,
                                                <<<<<<<<<<(get_generated_module_name(
                                                                        erlang:element(
                                                                            2,
                                                                            Module@1
                                                                        )
                                                                    ))/binary,
                                                                    "."/utf8>>/binary,
                                                                (justin:snake_case(
                                                                    erlang:element(
                                                                        3,
                                                                        erlang:element(
                                                                            3,
                                                                            Source@1
                                                                        )
                                                                    )
                                                                ))/binary>>/binary,
                                                            "_to_json("/utf8>>/binary,
                                                        (begin
                                                            _pipe@3 = [Variable |
                                                                gleam@list:map(
                                                                    Other_arguments,
                                                                    fun(
                                                                        Argument@1
                                                                    ) ->
                                                                        erlang:element(
                                                                            1,
                                                                            Argument@1
                                                                        )
                                                                    end
                                                                )],
                                                            _pipe@4 = gleam@list:unique(
                                                                _pipe@3
                                                            ),
                                                            gleam@string:join(
                                                                _pipe@4,
                                                                <<","/utf8>>
                                                            )
                                                        end)/binary>>/binary,
                                                    ")"/utf8>>,
                                                [get_generated_module_name(
                                                        erlang:element(
                                                            4,
                                                            Module@1
                                                        )
                                                    )],
                                                Other_arguments}
                                    end;

                                {error, _} ->
                                    Parameters@7 = case Type_ of
                                        {named_type, _, _, _, Parameters@6} ->
                                            Parameters@6;

                                        _ ->
                                            []
                                    end,
                                    Function@1 = <<<<(justin:snake_case(
                                                erlang:element(
                                                    3,
                                                    erlang:element(3, Source@1)
                                                )
                                            ))/binary,
                                            (case Parameters@7 of
                                                [] ->
                                                    <<""/utf8>>;

                                                _ ->
                                                    <<"_"/utf8,
                                                        (begin
                                                            _pipe@5 = gleam@list:map(
                                                                Parameters@7,
                                                                fun(Parameter@1) ->
                                                                    case Parameter@1 of
                                                                        {named_type,
                                                                            _,
                                                                            Name@3,
                                                                            _,
                                                                            _} ->
                                                                            justin:snake_case(
                                                                                Name@3
                                                                            );

                                                                        _ ->
                                                                            <<""/utf8>>
                                                                    end
                                                                end
                                                            ),
                                                            gleam@string:join(
                                                                _pipe@5,
                                                                <<"_"/utf8>>
                                                            )
                                                        end)/binary>>
                                            end)/binary>>/binary,
                                        "_to_json"/utf8>>,
                                    {generated_code,
                                        <<<<<<Function@1/binary, "("/utf8>>/binary,
                                                Variable/binary>>/binary,
                                            ")"/utf8>>,
                                        [erlang:element(4, Module@1)],
                                        [{Function@1,
                                                <<<<<<<<"fn("/utf8,
                                                                (module_name_for_path(
                                                                    erlang:element(
                                                                        2,
                                                                        Module@1
                                                                    )
                                                                ))/binary>>/binary,
                                                            (erlang:element(
                                                                3,
                                                                erlang:element(
                                                                    3,
                                                                    Source@1
                                                                )
                                                            ))/binary>>/binary,
                                                        (case Parameters@7 of
                                                            [] ->
                                                                <<""/utf8>>;

                                                            _ ->
                                                                <<<<"("/utf8,
                                                                        (begin
                                                                            _pipe@6 = gleam@list:map(
                                                                                Parameters@7,
                                                                                fun(
                                                                                    Parameter@2
                                                                                ) ->
                                                                                    case Parameter@2 of
                                                                                        {named_type,
                                                                                            _,
                                                                                            Name@4,
                                                                                            _,
                                                                                            _} ->
                                                                                            Name@4;

                                                                                        _ ->
                                                                                            <<""/utf8>>
                                                                                    end
                                                                                end
                                                                            ),
                                                                            gleam@string:join(
                                                                                _pipe@6,
                                                                                <<","/utf8>>
                                                                            )
                                                                        end)/binary>>/binary,
                                                                    ")"/utf8>>
                                                        end)/binary>>/binary,
                                                    ") -> json.Json"/utf8>>}]}
                            end
                    end
            end;

        {error, _} ->
            Parameters@9 = case Type_ of
                {named_type, _, _, _, Parameters@8} ->
                    Parameters@8;

                _ ->
                    []
            end,
            Function@2 = <<<<(justin:snake_case(case Type_ of
                            {named_type, _, Name@5, _, _} ->
                                Name@5;

                            _ ->
                                <<""/utf8>>
                        end))/binary, (case Parameters@9 of
                        [] ->
                            case Type_ of
                                {function_type, _, _, _} ->
                                    Variable;

                                _ ->
                                    <<""/utf8>>
                            end;

                        _ ->
                            <<"_"/utf8,
                                (begin
                                    _pipe@7 = gleam@list:map(
                                        Parameters@9,
                                        fun(Parameter@3) -> case Parameter@3 of
                                                {named_type, _, Name@6, _, _} ->
                                                    justin:snake_case(Name@6);

                                                _ ->
                                                    <<""/utf8>>
                                            end end
                                    ),
                                    gleam@string:join(_pipe@7, <<"_"/utf8>>)
                                end)/binary>>
                    end)/binary>>/binary, "_to_json"/utf8>>,
            {generated_code,
                <<<<<<Function@2/binary, "("/utf8>>/binary, Variable/binary>>/binary,
                    ")"/utf8>>,
                [],
                [{Function@2, <<""/utf8>>}]}
    end.

-file("src/sara/json.gleam", 405).
-spec json_encode_type(
    config(),
    builder@context:build_context(),
    glance:type(),
    binary(),
    builder@module:module_(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_encode_type(
    Config,
    Ctx,
    Type_,
    Variable,
    Current_module,
    Original_module,
    Custom_type_path
) ->
    Is_prelude = builder@inspect:is_prelude_type(Ctx, Type_, Current_module),
    case Type_ of
        {named_type, _, Name, _, Parameters} ->
            case {Name, Is_prelude} of
                {<<"Int"/utf8>>, true} ->
                    {generated_code,
                        <<<<"json.int("/utf8, Variable/binary>>/binary,
                            ")"/utf8>>,
                        [],
                        []};

                {<<"Float"/utf8>>, true} ->
                    {generated_code,
                        <<<<"json.float("/utf8, Variable/binary>>/binary,
                            ")"/utf8>>,
                        [],
                        []};

                {<<"Bool"/utf8>>, true} ->
                    {generated_code,
                        <<<<"json.bool("/utf8, Variable/binary>>/binary,
                            ")"/utf8>>,
                        [],
                        []};

                {<<"String"/utf8>>, true} ->
                    {generated_code,
                        <<<<"json.string("/utf8, Variable/binary>>/binary,
                            ")"/utf8>>,
                        [],
                        []};

                {<<"List"/utf8>>, true} ->
                    Type_@2 = case Parameters of
                        [Type_@1 | _] -> Type_@1;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"sara/json"/utf8>>,
                                        function => <<"json_encode_type"/utf8>>,
                                        line => 425,
                                        value => _assert_fail,
                                        start => 11074,
                                        'end' => 11109,
                                        pattern_start => 11085,
                                        pattern_end => 11096})
                    end,
                    List_encoder = json_encode_type(
                        Config,
                        Ctx,
                        Type_@2,
                        <<"x"/utf8>>,
                        Current_module,
                        Original_module,
                        Custom_type_path
                    ),
                    {generated_code,
                        <<<<<<<<"json.array("/utf8, Variable/binary>>/binary,
                                    ", fn (x) {"/utf8>>/binary,
                                ((erlang:element(2, List_encoder)))/binary>>/binary,
                            "})"/utf8>>,
                        erlang:element(3, List_encoder),
                        erlang:element(4, List_encoder)};

                {_, _} ->
                    json_encode_type_generic(
                        Config,
                        Ctx,
                        Type_,
                        Variable,
                        Current_module,
                        Original_module,
                        Custom_type_path
                    )
            end;

        {tuple_type, _, Elements} ->
            Codes = gleam@list:index_map(
                Elements,
                fun(Element, I) ->
                    json_encode_type(
                        Config,
                        Ctx,
                        Element,
                        <<<<Variable/binary, "."/utf8>>/binary,
                            (erlang:integer_to_binary(I))/binary>>,
                        Current_module,
                        Original_module,
                        Custom_type_path
                    )
                end
            ),
            {generated_code,
                <<<<"json.preprocessed_array([\n"/utf8,
                        (begin
                            _pipe = Codes,
                            _pipe@1 = gleam@list:map(
                                _pipe,
                                fun(Code) -> erlang:element(2, Code) end
                            ),
                            gleam@string:join(_pipe@1, <<",\n"/utf8>>)
                        end)/binary>>/binary,
                    "])"/utf8>>,
                begin
                    _pipe@2 = gleam@list:map(
                        Codes,
                        fun(Code@1) -> erlang:element(3, Code@1) end
                    ),
                    gleam@list:fold(
                        _pipe@2,
                        [],
                        fun(Acc, Imports) -> lists:append(Acc, Imports) end
                    )
                end,
                begin
                    _pipe@3 = gleam@list:map(
                        Codes,
                        fun(Code@2) -> erlang:element(4, Code@2) end
                    ),
                    gleam@list:fold(
                        _pipe@3,
                        [],
                        fun(Acc@1, Arguments) ->
                            lists:append(Acc@1, Arguments)
                        end
                    )
                end};

        {function_type, _, _, _} ->
            json_encode_type_generic(
                Config,
                Ctx,
                Type_,
                Variable,
                Current_module,
                Original_module,
                Custom_type_path
            );

        _ ->
            {generated_code, <<"todo"/utf8>>, [], []}
    end.

-file("src/sara/json.gleam", 309).
-spec json_encode_variant(
    config(),
    builder@context:build_context(),
    glance:variant(),
    boolean(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_encode_variant(
    Config,
    Ctx,
    Variant,
    Has_variant_type,
    Module,
    Custom_type_path
) ->
    Output = <<""/utf8>>,
    Output@1 = <<<<<<<<Output/binary,
                    (module_name_for_path(erlang:element(2, Module)))/binary>>/binary,
                (erlang:element(2, Variant))/binary>>/binary,
            (case gleam@list:is_empty(erlang:element(3, Variant)) of
                false ->
                    Parameters = begin
                        _pipe = gleam@list:index_map(
                            erlang:element(3, Variant),
                            fun(Field, I) -> case Field of
                                    {labelled_variant_field, _, Label} ->
                                        <<Label/binary, ":"/utf8>>;

                                    {unlabelled_variant_field, _} ->
                                        <<"field"/utf8,
                                            (erlang:integer_to_binary(I))/binary>>
                                end end
                        ),
                        gleam@string:join(_pipe, <<","/utf8>>)
                    end,
                    <<<<"("/utf8, Parameters/binary>>/binary, ")"/utf8>>;

                _ ->
                    <<""/utf8>>
            end)/binary>>/binary,
        "->\n"/utf8>>,
    Output@2 = <<Output@1/binary, "json.object([\n"/utf8>>,
    Output@3 = <<Output@2/binary, (case Has_variant_type of
            true ->
                <<<<<<<<<<<<"#(\""/utf8, "type"/utf8>>/binary, "\","/utf8>>/binary,
                                "json.string(\""/utf8>>/binary,
                            (justin:snake_case(erlang:element(2, Variant)))/binary>>/binary,
                        "\")"/utf8>>/binary,
                    "),\n"/utf8>>;

            _ ->
                <<""/utf8>>
        end)/binary>>,
    Fields = gleam@list:index_map(
        erlang:element(3, Variant),
        fun(Field@1, I@1) ->
            Variable = case Field@1 of
                {labelled_variant_field, _, Label@1} ->
                    Label@1;

                {unlabelled_variant_field, _} ->
                    <<"field"/utf8, (erlang:integer_to_binary(I@1))/binary>>
            end,
            case erlang:element(2, Field@1) of
                {variable_type, _, _} ->
                    {generated_code,
                        <<"todo as \"cant handle generic\""/utf8>>,
                        [],
                        []};

                _ ->
                    {generated_code, Code, Imports, Arguments} = json_encode_type(
                        Config,
                        Ctx,
                        erlang:element(2, Field@1),
                        Variable,
                        Module,
                        Module,
                        Custom_type_path
                    ),
                    {generated_code,
                        <<<<<<<<"#(\""/utf8, Variable/binary>>/binary,
                                    "\","/utf8>>/binary,
                                Code/binary>>/binary,
                            "),\n"/utf8>>,
                        Imports,
                        Arguments}
            end
        end
    ),
    Output@4 = <<Output@3/binary,
        (begin
            _pipe@1 = Fields,
            _pipe@2 = gleam@list:map(
                _pipe@1,
                fun(Field@2) -> erlang:element(2, Field@2) end
            ),
            gleam@string:join(_pipe@2, <<""/utf8>>)
        end)/binary>>,
    Output@5 = <<Output@4/binary, "])\n"/utf8>>,
    {generated_code,
        Output@5,
        begin
            _pipe@3 = gleam@list:map(
                Fields,
                fun(Field@3) -> erlang:element(3, Field@3) end
            ),
            gleam@list:fold(
                _pipe@3,
                [],
                fun(Acc, Imports@1) -> lists:append(Acc, Imports@1) end
            )
        end,
        begin
            _pipe@4 = gleam@list:map(
                Fields,
                fun(Field@4) -> erlang:element(4, Field@4) end
            ),
            gleam@list:fold(
                _pipe@4,
                [],
                fun(Acc@1, Arguments@1) -> lists:append(Acc@1, Arguments@1) end
            )
        end}.

-file("src/sara/json.gleam", 268).
-spec json_encode_custom_type(
    config(),
    builder@context:build_context(),
    glance:custom_type(),
    binary(),
    builder@module:module_(),
    gleam@set:set(glance:custom_type())
) -> generated_code().
json_encode_custom_type(
    Config,
    Ctx,
    Custom_type,
    Variable,
    Module,
    Custom_type_path
) ->
    Output = <<<<"case "/utf8, Variable/binary>>/binary, "{\n"/utf8>>,
    Variants = gleam@list:map(
        erlang:element(7, Custom_type),
        fun(Variant) ->
            json_encode_variant(
                Config,
                Ctx,
                Variant,
                case erlang:element(7, Custom_type) of
                    [_] ->
                        false;

                    _ ->
                        true
                end,
                Module,
                Custom_type_path
            )
        end
    ),
    Output@1 = <<Output/binary,
        (begin
            _pipe = Variants,
            _pipe@1 = gleam@list:map(
                _pipe,
                fun(Variant@1) -> erlang:element(2, Variant@1) end
            ),
            gleam@string:join(_pipe@1, <<"\n"/utf8>>)
        end)/binary>>,
    Output@2 = <<Output@1/binary, "}\n"/utf8>>,
    {generated_code,
        Output@2,
        begin
            _pipe@2 = gleam@list:map(
                Variants,
                fun(Variant@2) -> erlang:element(3, Variant@2) end
            ),
            gleam@list:fold(
                _pipe@2,
                [],
                fun(Acc, Imports) -> lists:append(Acc, Imports) end
            )
        end,
        begin
            _pipe@3 = gleam@list:map(
                Variants,
                fun(Variant@3) -> erlang:element(4, Variant@3) end
            ),
            gleam@list:fold(
                _pipe@3,
                [],
                fun(Acc@1, Arguments) -> lists:append(Acc@1, Arguments) end
            )
        end}.

-file("src/sara/json.gleam", 234).
-spec json_create_custom_type_encode_function(
    config(),
    builder@context:build_context(),
    glance:custom_type(),
    builder@module:module_()
) -> generated_code().
json_create_custom_type_encode_function(Config, Ctx, Custom_type, Module) ->
    X = justin:snake_case(erlang:element(3, Custom_type)),
    {generated_code, Code, Imports, Arguments} = json_encode_custom_type(
        Config,
        Ctx,
        Custom_type,
        X,
        Module,
        gleam@set:new()
    ),
    Output = <<<<<<<<"pub fn "/utf8, X/binary>>/binary, "_to_json("/utf8>>/binary,
            (begin
                _pipe = [<<<<<<X/binary, ": "/utf8>>/binary,
                            (module_name_for_path(erlang:element(2, Module)))/binary>>/binary,
                        (erlang:element(3, Custom_type))/binary>> |
                    gleam@list:map(
                        Arguments,
                        fun(Argument) -> case erlang:element(2, Argument) of
                                <<""/utf8>> ->
                                    erlang:element(1, Argument);

                                _ ->
                                    <<<<(erlang:element(1, Argument))/binary,
                                            ":"/utf8>>/binary,
                                        (erlang:element(2, Argument))/binary>>
                            end end
                    )],
                _pipe@1 = gleam@list:unique(_pipe),
                gleam@string:join(_pipe@1, <<","/utf8>>)
            end)/binary>>/binary,
        ") -> json.Json {\n"/utf8>>,
    Output@1 = <<Output/binary, Code/binary>>,
    Output@2 = <<Output@1/binary, "}"/utf8>>,
    {generated_code, Output@2, Imports, Arguments}.

-file("src/sara/json.gleam", 144).
?DOC(" Creates a builder that generates JSON encoding and decoding functions.\n").
-spec json_serializable_builder(config()) -> builder@core:builder().
json_serializable_builder(Config) ->
    builder:new_gleam_builder(
        fun(Ctx, Input) ->
            Encoders = begin
                Json_encodes = begin
                    _pipe = erlang:element(6, erlang:element(2, Input)),
                    builder@inspect:filter_attributes(
                        _pipe,
                        <<"json_encode"/utf8>>
                    )
                end,
                gleam@bool:guard(
                    gleam@list:is_empty(Json_encodes),
                    [],
                    fun() ->
                        [{generated_code,
                                <<""/utf8>>,
                                [<<"gleam/json"/utf8>>],
                                []} |
                            begin
                                _pipe@1 = gleam@list:map(
                                    Json_encodes,
                                    fun(Entry) ->
                                        json_create_custom_type_encode_function(
                                            Config,
                                            Ctx,
                                            erlang:element(2, Entry),
                                            erlang:element(2, Input)
                                        )
                                    end
                                ),
                                lists:reverse(_pipe@1)
                            end]
                    end
                )
            end,
            Decoders = begin
                Json_decodes = begin
                    _pipe@2 = erlang:element(6, erlang:element(2, Input)),
                    builder@inspect:filter_attributes(
                        _pipe@2,
                        <<"json_decode"/utf8>>
                    )
                end,
                gleam@bool:guard(
                    gleam@list:is_empty(Json_decodes),
                    [],
                    fun() ->
                        [{generated_code,
                                <<""/utf8>>,
                                [<<"gleam/dynamic/decode"/utf8>>],
                                []} |
                            begin
                                _pipe@3 = gleam@list:map(
                                    Json_decodes,
                                    fun(Entry@1) ->
                                        json_create_custom_type_decode_function(
                                            Config,
                                            Ctx,
                                            erlang:element(2, Entry@1),
                                            erlang:element(2, Input)
                                        )
                                    end
                                ),
                                lists:reverse(_pipe@3)
                            end]
                    end
                )
            end,
            Codecs = lists:append(Encoders, Decoders),
            gleam@bool:guard(
                gleam@list:is_empty(Codecs),
                nil,
                fun() ->
                    Imports@1 = begin
                        _pipe@4 = [erlang:element(4, erlang:element(2, Input))],
                        lists:append(
                            _pipe@4,
                            begin
                                _pipe@5 = gleam@list:map(
                                    Codecs,
                                    fun(Codec) -> erlang:element(3, Codec) end
                                ),
                                gleam@list:fold(
                                    _pipe@5,
                                    [],
                                    fun(Acc, Imports) ->
                                        lists:append(Acc, Imports)
                                    end
                                )
                            end
                        )
                    end,
                    Output = <<<<"import "/utf8,
                            (begin
                                _pipe@6 = Imports@1,
                                _pipe@7 = gleam@list:unique(_pipe@6),
                                gleam@string:join(_pipe@7, <<"\nimport "/utf8>>)
                            end)/binary>>/binary,
                        "\n"/utf8>>,
                    Output@1 = <<Output/binary,
                        (begin
                            _pipe@8 = Codecs,
                            _pipe@9 = gleam@list:map(
                                _pipe@8,
                                fun(Codec@1) -> erlang:element(2, Codec@1) end
                            ),
                            gleam@string:join(_pipe@9, <<"\n"/utf8>>)
                        end)/binary>>,
                    Code@1 = case builder_format_ffi:format_gleam_code(Output@1) of
                        {ok, Code} -> Code;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"sara/json"/utf8>>,
                                        function => <<"json_serializable_builder"/utf8>>,
                                        line => 210,
                                        value => _assert_fail,
                                        start => 5841,
                                        'end' => 5895,
                                        pattern_start => 5852,
                                        pattern_end => 5860})
                    end,
                    gleam_stdlib:println(
                        <<"✨ Generated: "/utf8,
                            (erlang:element(
                                2,
                                (builder@asset:change_extension(
                                    erlang:element(3, Input),
                                    <<"_json.gleam"/utf8>>
                                ))
                            ))/binary>>
                    ),
                    _ = builder@context:write(
                        Ctx,
                        begin
                            _pipe@10 = erlang:element(3, Input),
                            builder@asset:change_extension(
                                _pipe@10,
                                <<"_json.gleam"/utf8>>
                            )
                        end,
                        Code@1
                    ),
                    nil
                end
            )
        end
    ).