-module(json@blueprint).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([generate_json_schema/1, self_decoder/1, get_dynamic_decoder/1, decode/2, string/0, int/0, float/0, bool/0, list/1, reuse_decoder/1, field/2, optional/1, optional_field/2, encode_optional_field/4, union_type_encoder/2, union_type_decoder/1, enum_type_encoder/2, enum_type_decoder/1, map/2, tuple2/2, tuple3/3, tuple4/4, tuple5/5, tuple6/6, decode0/1, decode1/2, decode2/3, decode3/4, decode4/5, decode5/6, decode6/7, decode7/8, decode8/9, decode9/10, encode_tuple2/3, encode_tuple3/4, encode_tuple4/5, encode_tuple5/6, encode_tuple6/7, encode_tuple7/8, encode_tuple8/9, encode_tuple9/10]).
-export_type([decoder/1, field_decoder/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type decoder(GTW) :: {decoder,
        fun((gleam@dynamic:dynamic_()) -> {ok, GTW} |
            {error, list(gleam@dynamic:decode_error())}),
        json@blueprint@schema:schema_definition(),
        list({binary(), json@blueprint@schema:schema_definition()})}.

-type field_decoder(GTX) :: {field_decoder,
        fun((gleam@dynamic:dynamic_()) -> {ok, GTX} |
            {error, list(gleam@dynamic:decode_error())}),
        {binary(), json@blueprint@schema:schema_definition()},
        list({binary(), json@blueprint@schema:schema_definition()})}.

-file("src/json/blueprint.gleam", 32).
-spec generate_json_schema(decoder(any())) -> gleam@json:json().
generate_json_schema(Decoder) ->
    Refs = case erlang:element(4, Decoder) of
        [] ->
            none;

        Xs ->
            {some, Xs}
    end,
    json@blueprint@schema:to_json(
        json@blueprint@schema:new_schema(erlang:element(3, Decoder), Refs)
    ).

-file("src/json/blueprint.gleam", 132).
?DOC(
    " Creates a decoder for recursive data types by allowing self-referential definitions.\n"
    " This is useful when you have types that contain themselves, like trees or linked lists.\n"
    "\n"
    " The function takes a lazy decoder (a function that returns a decoder) to break the\n"
    " recursive dependency cycle. The returned decoder uses a JSON Schema reference \"#\"\n"
    " to point to the root schema definition.\n"
    "\n"
    " > ❗ _**IMPORTANT**_\n"
    " > Add the reuse_decoder when there are nested recursive types so\n"
    " > the schema references (`#`) get rewritten correctly and self-references from the\n"
    " > different types don't get mixed up. As a recommendation, always add it when\n"
    " > decoding recursive types.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " // A binary tree type that can contain itself\n"
    " pub type Tree {\n"
    "   Node(value: Int, left: Option(Tree), right: Option(Tree))\n"
    "   Leaf(value: Int)\n"
    " }\n"
    "\n"
    " // Create a recursive decoder for the Tree type\n"
    " pub fn tree_decoder() -> Decoder(Tree) {\n"
    "   // Use union_type_decoder for handling different variants\n"
    "   union_type_decoder([\n"
    "     #(\"leaf\", decode1(Leaf, field(\"value\", int()))),\n"
    "     #(\"node\", decode3(\n"
    "       Node,\n"
    "       field(\"value\", int()),\n"
    "       // Use self_decoder to handle recursive fields\n"
    "       field(\"left\", optional(self_decoder(tree_decoder))),\n"
    "       field(\"right\", optional(self_decoder(tree_decoder))),\n"
    "     )),\n"
    "   ])\n"
    "   |> reuse_decoder\n"
    " }\n"
    " ```\n"
).
-spec self_decoder(fun(() -> decoder(GUJ))) -> decoder(GUJ).
self_decoder(Lazy) ->
    {decoder,
        fun(Input) -> (erlang:element(2, Lazy()))(Input) end,
        {ref, <<"#"/utf8>>},
        []}.

-file("src/json/blueprint.gleam", 136).
-spec get_dynamic_decoder(decoder(GUM)) -> fun((gleam@dynamic:dynamic_()) -> {ok,
        GUM} |
    {error, list(gleam@dynamic:decode_error())}).
get_dynamic_decoder(Decoder) ->
    erlang:element(2, Decoder).

-file("src/json/blueprint.gleam", 140).
-spec decode(decoder(GUP), binary()) -> {ok, GUP} |
    {error, gleam@json:decode_error()}.
decode(Decoder, Json_string) ->
    gleam@json:decode(Json_string, erlang:element(2, Decoder)).

-file("src/json/blueprint.gleam", 147).
-spec string() -> decoder(binary()).
string() ->
    {decoder, fun json@blueprint@dynamic:string/1, {type, string_type}, []}.

-file("src/json/blueprint.gleam", 151).
-spec int() -> decoder(integer()).
int() ->
    {decoder, fun json@blueprint@dynamic:int/1, {type, integer_type}, []}.

-file("src/json/blueprint.gleam", 155).
-spec float() -> decoder(float()).
float() ->
    {decoder, fun json@blueprint@dynamic:float/1, {type, number_type}, []}.

-file("src/json/blueprint.gleam", 159).
-spec bool() -> decoder(boolean()).
bool() ->
    {decoder, fun json@blueprint@dynamic:bool/1, {type, boolean_type}, []}.

-file("src/json/blueprint.gleam", 163).
-spec list(decoder(GUX)) -> decoder(list(GUX)).
list(Decoder_type) ->
    {decoder,
        json@blueprint@dynamic:list(erlang:element(2, Decoder_type)),
        {array, {some, erlang:element(3, Decoder_type)}},
        erlang:element(4, Decoder_type)}.

-file("src/json/blueprint.gleam", 75).
?DOC(
    " Creates a reusable version of a decoder that can be used multiple times in a schema\n"
    " without duplicating the schema definition.\n"
    "\n"
    " The function:\n"
    " 1. Creates a unique reference name based on the schema's hash\n"
    " 2. Moves the original schema into the `$defs` section\n"
    " 3. Returns a new decoder that references the schema via `$ref`\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " type Person {\n"
    "   Person(name: String, friends: List(Pet))\n"
    " }\n"
    "\n"
    " type Pet {\n"
    "   Pet(name: String)\n"
    " }\n"
    "\n"
    "\n"
    " let pet_decoder = reuse_decoder(\n"
    "   decode2(\n"
    "     Pet,\n"
    "     field(\"name\", string()),\n"
    "   )\n"
    " )\n"
    "\n"
    " let person_decoder = reuse_decoder(\n"
    "   decode2(\n"
    "     Person,\n"
    "     field(\"name\", string()),\n"
    "     field(\"friends\", list(pet_decoder))\n"
    "   )\n"
    " )\n"
    " ```\n"
).
-spec reuse_decoder(decoder(GUG)) -> decoder(GUG).
reuse_decoder(Decoder) ->
    Def_name = <<"ref_"/utf8,
        (json@blueprint@schema:hash_schema_definition(
            erlang:element(3, Decoder)
        ))/binary>>,
    Ref_name = <<"#/$defs/"/utf8, Def_name/binary>>,
    Schema_with_rebased_self_refs = json@blueprint@schema:map_ref(
        erlang:element(3, Decoder),
        fun(Original_ref_name) -> case Original_ref_name of
                <<"#"/utf8>> ->
                    Ref_name;

                X ->
                    X
            end end
    ),
    {decoder,
        erlang:element(2, Decoder),
        {ref, Ref_name},
        begin
            _pipe = erlang:element(4, Decoder),
            gleam@list:prepend(_pipe, {Def_name, Schema_with_rebased_self_refs})
        end}.

-file("src/json/blueprint.gleam", 171).
-spec field(binary(), decoder(GVB)) -> field_decoder(GVB).
field(Name, Inner_type) ->
    {field_decoder,
        json@blueprint@dynamic:field(Name, erlang:element(2, Inner_type)),
        {Name, erlang:element(3, Inner_type)},
        erlang:element(4, Inner_type)}.

-file("src/json/blueprint.gleam", 201).
?DOC(
    " Creates a decoder that can handle `null` values by wrapping the result in an `Option` type.\n"
    " When the value is `null`, it returns `None`. Otherwise, it uses the provided decoder\n"
    " to decode the value and wraps the result in `Some`. If you need the decoder to handle a possible missing field\n"
    " (i.e., the field is absent from the JSON), use the `optional_field` function instead.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " type User {\n"
    "   User(name: String, age: Option(Int))\n"
    " }\n"
    "\n"
    " let decoder = decode2(\n"
    "   User,\n"
    "   field(\"name\", string()),\n"
    "   field(\"age\", optional(int()))  // Will handle \"age\": null\n"
    " )\n"
    "\n"
    " // These JSON strings will decode successfully:\n"
    " // {\"name\": \"Alice\", \"age\": 25}  -> User(\"Alice\", Some(25))\n"
    " // {\"name\": \"Bob\", \"age\": null}  -> User(\"Bob\", None)\n"
    " ```\n"
).
-spec optional(decoder(GVE)) -> decoder(gleam@option:option(GVE)).
optional(Decode) ->
    {decoder,
        json@blueprint@dynamic:optional(erlang:element(2, Decode)),
        {nullable, erlang:element(3, Decode)},
        erlang:element(4, Decode)}.

-file("src/json/blueprint.gleam", 237).
?DOC(
    " Decode a field that can be missing or have a `null` value into an `Option` type.\n"
    " This function is useful when you want to handle both cases where a field is absent from the JSON\n"
    " or when it's explicitly set to `null`.\n"
    "\n"
    " If you only need to handle fields that are present but might be `null`, use the `optional` function instead.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " type User {\n"
    "   User(name: String, age: Option(Int))\n"
    " }\n"
    "\n"
    " let decoder = decode2(\n"
    "   User,\n"
    "   field(\"name\", string()),\n"
    "   optional_field(\"age\", int())  // Will handle both missing \"age\" field and \"age\": null\n"
    " )\n"
    "\n"
    " // All these JSON strings will decode successfully:\n"
    " // {\"name\": \"Alice\", \"age\": 25}     -> User(\"Alice\", Some(25))\n"
    " // {\"name\": \"Bob\", \"age\": null}     -> User(\"Bob\", None)\n"
    " // {\"name\": \"Charlie\"}              -> User(\"Charlie\", None)\n"
    " ```\n"
).
-spec optional_field(binary(), decoder(GVI)) -> field_decoder(gleam@option:option(GVI)).
optional_field(Name, Inner_type) ->
    {field_decoder,
        fun(Value) ->
            _pipe = (json@blueprint@dynamic:optional_field(
                Name,
                fun(Dyn) -> case Dyn =:= json_blueprint_ffi:null() of
                        false ->
                            gleam@result:map(
                                (erlang:element(2, Inner_type))(Dyn),
                                fun(Field@0) -> {some, Field@0} end
                            );

                        true ->
                            {ok, none}
                    end end
            ))(Value),
            gleam@result:map(_pipe, fun gleam@option:flatten/1)
        end,
        {Name, {optional, erlang:element(3, Inner_type)}},
        erlang:element(4, Inner_type)}.

-file("src/json/blueprint.gleam", 299).
?DOC(
    " Adds an optional field to a list of key-value pairs that will be used to create a JSON object.\n"
    " This is particularly useful when defining JSON encoder to pair up to the `optional_field` decoder.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " fn tree_decoder() {\n"
    "   blueprint.union_type_decoder([\n"
    "     #(\n"
    "       \"node\",\n"
    "       blueprint.decode3(\n"
    "         Node,\n"
    "         blueprint.field(\"value\", blueprint.int()),\n"
    "         // This is an optional field for an optional value\n"
    "         blueprint.optional_field(\"left\", blueprint.self_decoder(tree_decoder)),\n"
    "         // And this is a required field with an optional value\n"
    "         blueprint.field(\n"
    "           \"right\",\n"
    "           blueprint.optional(blueprint.self_decoder(tree_decoder)),\n"
    "         ),\n"
    "       ),\n"
    "     ),\n"
    "   ])\n"
    "   |> blueprint.reuse_decoder\n"
    " }\n"
    "\n"
    " fn encode_tree(tree: Tree) -> json.Json {\n"
    "   blueprint.union_type_encoder(tree, fn(node) {\n"
    "     case node {\n"
    "       Node(value, left, right) -> #(\n"
    "         \"node\",\n"
    "         [\n"
    "           #(\"value\", json.int(value)),\n"
    "           // This is a required field with an optional value\n"
    "           #(\"right\", json.nullable(right, encode_tree)),\n"
    "         ]\n"
    "           // And this is an optional field for an optional value\n"
    "           |> blueprint.encode_optional_field(\"left\", left, encode_tree)\n"
    "           |> json.object(),\n"
    "       )\n"
    "     }\n"
    "   })\n"
    " }\n"
    " ```\n"
).
-spec encode_optional_field(
    list({binary(), gleam@json:json()}),
    binary(),
    gleam@option:option(GVN),
    fun((GVN) -> gleam@json:json())
) -> list({binary(), gleam@json:json()}).
encode_optional_field(Fields, Name, Value, Encode_fn) ->
    case Value of
        {some, Left} ->
            gleam@list:prepend(Fields, {Name, Encode_fn(Left)});

        none ->
            Fields
    end.

-file("src/json/blueprint.gleam", 339).
?DOC(
    " Function to encode a union type into a JSON object.\n"
    " The function takes a value and an encoder function that returns a tuple of the type name and the JSON value.\n"
    "\n"
    "> [!IMPORTANT]\n"
    "> Make sure to update the decoder function accordingly.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " type Shape {\n"
    "   Circle(Float)\n"
    "   Rectangle(Float, Float)\n"
    " }\n"
    "\n"
    " let shape_encoder = union_type_encoder(fn(shape) {\n"
    "   case shape {\n"
    "     Circle(radius) -> #(\"circle\", json.object([#(\"radius\", json.float(radius))]))\n"
    "     Rectangle(width, height) -> #(\n"
    "       \"rectangle\",\n"
    "       json.object([\n"
    "         #(\"width\", json.float(width)),\n"
    "         #(\"height\", json.float(height))\n"
    "       ])\n"
    "     )\n"
    "   }\n"
    " })\n"
    " ```\n"
).
-spec union_type_encoder(GVQ, fun((GVQ) -> {binary(), gleam@json:json()})) -> gleam@json:json().
union_type_encoder(Of, Encoder_fn) ->
    {Field_name, Json_value} = Encoder_fn(Of),
    gleam@json:object(
        [{<<"type"/utf8>>, gleam@json:string(Field_name)},
            {<<"data"/utf8>>, Json_value}]
    ).

-file("src/json/blueprint.gleam", 369).
?DOC(
    " Function to defined a decoder for a union types.\n"
    " The function takes a list of decoders for each possible type of the union.\n"
    "\n"
    "> [!IMPORTANT]\n"
    "> Make sure to add tests for every possible type of the union because it is not possible to check for exhaustiveness in the case.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " type Shape {\n"
    "   Circle(Float)\n"
    "   Rectangle(Float, Float)\n"
    " }\n"
    "\n"
    " let shape_decoder = union_type_decoder([\n"
    "   #(\"circle\", decode1(Circle, field(\"radius\", float()))),\n"
    "   #(\"rectangle\", decode2(Rectangle,\n"
    "     field(\"width\", float()),\n"
    "     field(\"height\", float())\n"
    "   ))\n"
    " ])\n"
    " ```\n"
).
-spec union_type_decoder(list({binary(), decoder(GVR)})) -> decoder(GVR).
union_type_decoder(Decoders) ->
    Constructor = fun(Type_str, Data) -> _pipe = Decoders,
        _pipe@1 = gleam@list:find_map(
            _pipe,
            fun(Dec) -> case erlang:element(1, Dec) =:= Type_str of
                    true ->
                        {ok,
                            (erlang:element(2, (erlang:element(2, Dec))))(Data)};

                    _ ->
                        {error, []}
                end end
        ),
        _pipe@4 = gleam@result:map_error(
            _pipe@1,
            fun(_) ->
                Valid_types = begin
                    _pipe@2 = Decoders,
                    _pipe@3 = gleam@list:map(
                        _pipe@2,
                        fun(Dec@1) -> erlang:element(1, Dec@1) end
                    ),
                    gleam@string:join(_pipe@3, <<", "/utf8>>)
                end,
                [{decode_error,
                        <<"valid constructor type, one of: "/utf8,
                            Valid_types/binary>>,
                        Type_str,
                        []}]
            end
        ),
        gleam@result:flatten(_pipe@4) end,
    Enum_decoder = fun(Data@1) ->
        _pipe@5 = (json@blueprint@dynamic:decode2(
            Constructor,
            json@blueprint@dynamic:field(
                <<"type"/utf8>>,
                fun json@blueprint@dynamic:string/1
            ),
            json@blueprint@dynamic:field(
                <<"data"/utf8>>,
                fun json@blueprint@dynamic:dynamic/1
            )
        ))(Data@1),
        gleam@result:flatten(_pipe@5)
    end,
    Schema = case Decoders of
        [] ->
            {object, [], {some, false}, none};

        [{Name, Dec@2}] ->
            {object,
                [{<<"type"/utf8>>,
                        {enum, [gleam@json:string(Name)], {some, string_type}}},
                    {<<"data"/utf8>>, erlang:element(3, Dec@2)}],
                {some, false},
                {some, [<<"type"/utf8>>, <<"data"/utf8>>]}};

        Xs ->
            _pipe@6 = gleam@list:map(
                Xs,
                fun(Field_dec) ->
                    {Name@1, Dec@3} = Field_dec,
                    {object,
                        [{<<"type"/utf8>>,
                                {enum,
                                    [gleam@json:string(Name@1)],
                                    {some, string_type}}},
                            {<<"data"/utf8>>, erlang:element(3, Dec@3)}],
                        {some, false},
                        {some, [<<"type"/utf8>>, <<"data"/utf8>>]}}
                end
            ),
            {any_of, _pipe@6}
    end,
    Defs = gleam@list:flat_map(
        Decoders,
        fun(Dec@4) -> erlang:element(4, (erlang:element(2, Dec@4))) end
    ),
    {decoder, Enum_decoder, Schema, Defs}.

-file("src/json/blueprint.gleam", 465).
?DOC(
    " Function to encode an enum type (unions where constructors have no arguments) into a JSON object.\n"
    " The function takes a value and an encoder function that returns the string representation of the enum value.\n"
    "\n"
    "> [!IMPORTANT]\n"
    "> Make sure to update the decoder function accordingly.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " type Color {\n"
    "   Red\n"
    "   Green\n"
    "   Blue\n"
    " }\n"
    "\n"
    " let color_encoder = enum_type_encoder(fn(color) {\n"
    "   case color {\n"
    "     Red -> \"red\"\n"
    "     Green -> \"green\"\n"
    "     Blue -> \"blue\"\n"
    "   }\n"
    " })\n"
    " ```\n"
).
-spec enum_type_encoder(GVV, fun((GVV) -> binary())) -> gleam@json:json().
enum_type_encoder(Of, Encoder_fn) ->
    Field_name = Encoder_fn(Of),
    gleam@json:object([{<<"enum"/utf8>>, gleam@json:string(Field_name)}]).

-file("src/json/blueprint.gleam", 494).
?DOC(
    " Function to define a decoder for enum types (unions where constructors have no arguments).\n"
    " The function takes a list of tuples containing the string representation and the corresponding enum value.\n"
    "\n"
    "> [!IMPORTANT]\n"
    "> Make sure to add tests for every possible enum value because it is not possible to check for exhaustiveness.\n"
    "\n"
    " ## Example\n"
    " ```gleam\n"
    " type Color {\n"
    "   Red\n"
    "   Green\n"
    "   Blue\n"
    " }\n"
    "\n"
    " let color_decoder = enum_type_decoder([\n"
    "   #(\"red\", Red),\n"
    "   #(\"green\", Green),\n"
    "   #(\"blue\", Blue),\n"
    " ])\n"
    " ```\n"
).
-spec enum_type_decoder(list({binary(), GVW})) -> decoder(GVW).
enum_type_decoder(Decoders) ->
    Constructor = fun(Type_str) -> _pipe = Decoders,
        _pipe@1 = gleam@list:find_map(
            _pipe,
            fun(Dec) -> case erlang:element(1, Dec) =:= Type_str of
                    true ->
                        {ok, erlang:element(2, Dec)};

                    _ ->
                        {error, []}
                end end
        ),
        gleam@result:map_error(
            _pipe@1,
            fun(_) ->
                Valid_types = begin
                    _pipe@2 = Decoders,
                    _pipe@3 = gleam@list:map(
                        _pipe@2,
                        fun(Dec@1) -> erlang:element(1, Dec@1) end
                    ),
                    gleam@string:join(_pipe@3, <<", "/utf8>>)
                end,
                [{decode_error,
                        <<"valid constructor type, one of: "/utf8,
                            Valid_types/binary>>,
                        Type_str,
                        []}]
            end
        ) end,
    Enum_decoder = fun(Data) ->
        _pipe@4 = (json@blueprint@dynamic:decode1(
            Constructor,
            json@blueprint@dynamic:field(
                <<"enum"/utf8>>,
                fun json@blueprint@dynamic:string/1
            )
        ))(Data),
        gleam@result:flatten(_pipe@4)
    end,
    {decoder,
        Enum_decoder,
        begin
            _pipe@5 = gleam@list:map(
                Decoders,
                fun(Field_dec) ->
                    gleam@json:string(erlang:element(1, Field_dec))
                end
            ),
            _pipe@6 = (fun(Enum_values) ->
                [{<<"enum"/utf8>>, {enum, Enum_values, {some, string_type}}}]
            end)(_pipe@5),
            {object, _pipe@6, {some, false}, {some, [<<"enum"/utf8>>]}}
        end,
        []}.

-file("src/json/blueprint.gleam", 540).
-spec map(decoder(GVZ), fun((GVZ) -> GWB)) -> decoder(GWB).
map(Decoder, Foo) ->
    {decoder,
        fun(Input) ->
            gleam@result:map((erlang:element(2, Decoder))(Input), Foo)
        end,
        erlang:element(3, Decoder),
        erlang:element(4, Decoder)}.

-file("src/json/blueprint.gleam", 548).
-spec tuple2(decoder(GWD), decoder(GWF)) -> decoder({GWD, GWF}).
tuple2(Decode1, Decode2) ->
    {decoder,
        json@blueprint@dynamic:tuple2(
            erlang:element(2, Decode1),
            erlang:element(2, Decode2)
        ),
        {detailed_array,
            none,
            {some, [erlang:element(3, Decode1), erlang:element(3, Decode2)]},
            {some, 2},
            {some, 2},
            none,
            none,
            none,
            none},
        lists:append(erlang:element(4, Decode1), erlang:element(4, Decode2))}.

-file("src/json/blueprint.gleam", 568).
-spec tuple3(decoder(GWI), decoder(GWK), decoder(GWM)) -> decoder({GWI,
    GWK,
    GWM}).
tuple3(Decode1, Decode2, Decode3) ->
    {decoder,
        json@blueprint@dynamic:tuple3(
            erlang:element(2, Decode1),
            erlang:element(2, Decode2),
            erlang:element(2, Decode3)
        ),
        {detailed_array,
            none,
            {some,
                [erlang:element(3, Decode1),
                    erlang:element(3, Decode2),
                    erlang:element(3, Decode3)]},
            {some, 3},
            {some, 3},
            none,
            none,
            none,
            none},
        gleam@list:flatten(
            [erlang:element(4, Decode1),
                erlang:element(4, Decode2),
                erlang:element(4, Decode3)]
        )}.

-file("src/json/blueprint.gleam", 593).
-spec tuple4(decoder(GWP), decoder(GWR), decoder(GWT), decoder(GWV)) -> decoder({GWP,
    GWR,
    GWT,
    GWV}).
tuple4(Decode1, Decode2, Decode3, Decode4) ->
    {decoder,
        json@blueprint@dynamic:tuple4(
            erlang:element(2, Decode1),
            erlang:element(2, Decode2),
            erlang:element(2, Decode3),
            erlang:element(2, Decode4)
        ),
        {detailed_array,
            none,
            {some,
                [erlang:element(3, Decode1),
                    erlang:element(3, Decode2),
                    erlang:element(3, Decode3),
                    erlang:element(3, Decode4)]},
            {some, 4},
            {some, 4},
            none,
            none,
            none,
            none},
        gleam@list:flatten(
            [erlang:element(4, Decode1),
                erlang:element(4, Decode2),
                erlang:element(4, Decode3),
                erlang:element(4, Decode4)]
        )}.

-file("src/json/blueprint.gleam", 620).
-spec tuple5(
    decoder(GWY),
    decoder(GXA),
    decoder(GXC),
    decoder(GXE),
    decoder(GXG)
) -> decoder({GWY, GXA, GXC, GXE, GXG}).
tuple5(Decode1, Decode2, Decode3, Decode4, Decode5) ->
    {decoder,
        json@blueprint@dynamic:tuple5(
            erlang:element(2, Decode1),
            erlang:element(2, Decode2),
            erlang:element(2, Decode3),
            erlang:element(2, Decode4),
            erlang:element(2, Decode5)
        ),
        {detailed_array,
            none,
            {some,
                [erlang:element(3, Decode1),
                    erlang:element(3, Decode2),
                    erlang:element(3, Decode3),
                    erlang:element(3, Decode4),
                    erlang:element(3, Decode5)]},
            {some, 5},
            {some, 5},
            none,
            none,
            none,
            none},
        gleam@list:flatten(
            [erlang:element(4, Decode1),
                erlang:element(4, Decode2),
                erlang:element(4, Decode3),
                erlang:element(4, Decode4),
                erlang:element(4, Decode5)]
        )}.

-file("src/json/blueprint.gleam", 661).
-spec tuple6(
    decoder(GXJ),
    decoder(GXL),
    decoder(GXN),
    decoder(GXP),
    decoder(GXR),
    decoder(GXT)
) -> decoder({GXJ, GXL, GXN, GXP, GXR, GXT}).
tuple6(Decode1, Decode2, Decode3, Decode4, Decode5, Decode6) ->
    {decoder,
        json@blueprint@dynamic:tuple6(
            erlang:element(2, Decode1),
            erlang:element(2, Decode2),
            erlang:element(2, Decode3),
            erlang:element(2, Decode4),
            erlang:element(2, Decode5),
            erlang:element(2, Decode6)
        ),
        {detailed_array,
            none,
            {some,
                [erlang:element(3, Decode1),
                    erlang:element(3, Decode2),
                    erlang:element(3, Decode3),
                    erlang:element(3, Decode4),
                    erlang:element(3, Decode5),
                    erlang:element(3, Decode6)]},
            {some, 6},
            {some, 6},
            none,
            none,
            none,
            none},
        gleam@list:flatten(
            [erlang:element(4, Decode1),
                erlang:element(4, Decode2),
                erlang:element(4, Decode3),
                erlang:element(4, Decode4),
                erlang:element(4, Decode5),
                erlang:element(4, Decode6)]
        )}.

-file("src/json/blueprint.gleam", 706).
-spec create_object_schema(
    list({binary(), json@blueprint@schema:schema_definition()})
) -> json@blueprint@schema:schema_definition().
create_object_schema(Fields) ->
    {object,
        Fields,
        {some, false},
        {some, gleam@list:filter_map(Fields, fun(Field_dec) -> case Field_dec of
                        {_, {optional, _}} ->
                            {error, nil};

                        {Name, _} ->
                            {ok, Name}
                    end end)}}.

-file("src/json/blueprint.gleam", 723).
-spec decode0(GXX) -> decoder(GXX).
decode0(Constructor) ->
    {decoder,
        fun(_) -> {ok, Constructor} end,
        {object, [], {some, false}, none},
        []}.

-file("src/json/blueprint.gleam", 750).
-spec decode1(fun((GXZ) -> GYA), field_decoder(GXZ)) -> decoder(GYA).
decode1(Constructor, T1) ->
    {decoder,
        json@blueprint@dynamic:decode1(Constructor, erlang:element(2, T1)),
        create_object_schema([erlang:element(3, T1)]),
        erlang:element(4, T1)}.

-file("src/json/blueprint.gleam", 758).
-spec decode2(fun((GYD, GYE) -> GYF), field_decoder(GYD), field_decoder(GYE)) -> decoder(GYF).
decode2(Constructor, T1, T2) ->
    {decoder,
        json@blueprint@dynamic:decode2(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2)
        ),
        create_object_schema([erlang:element(3, T1), erlang:element(3, T2)]),
        gleam@list:flatten([erlang:element(4, T1), erlang:element(4, T2)])}.

-file("src/json/blueprint.gleam", 770).
-spec decode3(
    fun((GYJ, GYK, GYL) -> GYM),
    field_decoder(GYJ),
    field_decoder(GYK),
    field_decoder(GYL)
) -> decoder(GYM).
decode3(Constructor, T1, T2, T3) ->
    {decoder,
        json@blueprint@dynamic:decode3(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2),
            erlang:element(2, T3)
        ),
        create_object_schema(
            [erlang:element(3, T1),
                erlang:element(3, T2),
                erlang:element(3, T3)]
        ),
        gleam@list:flatten(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3)]
        )}.

-file("src/json/blueprint.gleam", 783).
-spec decode4(
    fun((GYR, GYS, GYT, GYU) -> GYV),
    field_decoder(GYR),
    field_decoder(GYS),
    field_decoder(GYT),
    field_decoder(GYU)
) -> decoder(GYV).
decode4(Constructor, T1, T2, T3, T4) ->
    {decoder,
        json@blueprint@dynamic:decode4(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2),
            erlang:element(2, T3),
            erlang:element(2, T4)
        ),
        create_object_schema(
            [erlang:element(3, T1),
                erlang:element(3, T2),
                erlang:element(3, T3),
                erlang:element(3, T4)]
        ),
        gleam@list:flatten(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4)]
        )}.

-file("src/json/blueprint.gleam", 808).
-spec decode5(
    fun((GZB, GZC, GZD, GZE, GZF) -> GZG),
    field_decoder(GZB),
    field_decoder(GZC),
    field_decoder(GZD),
    field_decoder(GZE),
    field_decoder(GZF)
) -> decoder(GZG).
decode5(Constructor, T1, T2, T3, T4, T5) ->
    {decoder,
        json@blueprint@dynamic:decode5(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2),
            erlang:element(2, T3),
            erlang:element(2, T4),
            erlang:element(2, T5)
        ),
        create_object_schema(
            [erlang:element(3, T1),
                erlang:element(3, T2),
                erlang:element(3, T3),
                erlang:element(3, T4),
                erlang:element(3, T5)]
        ),
        gleam@list:flatten(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4),
                erlang:element(4, T5)]
        )}.

-file("src/json/blueprint.gleam", 836).
-spec decode6(
    fun((GZN, GZO, GZP, GZQ, GZR, GZS) -> GZT),
    field_decoder(GZN),
    field_decoder(GZO),
    field_decoder(GZP),
    field_decoder(GZQ),
    field_decoder(GZR),
    field_decoder(GZS)
) -> decoder(GZT).
decode6(Constructor, T1, T2, T3, T4, T5, T6) ->
    {decoder,
        json@blueprint@dynamic:decode6(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2),
            erlang:element(2, T3),
            erlang:element(2, T4),
            erlang:element(2, T5),
            erlang:element(2, T6)
        ),
        create_object_schema(
            [erlang:element(3, T1),
                erlang:element(3, T2),
                erlang:element(3, T3),
                erlang:element(3, T4),
                erlang:element(3, T5),
                erlang:element(3, T6)]
        ),
        gleam@list:flatten(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4),
                erlang:element(4, T5),
                erlang:element(4, T6)]
        )}.

-file("src/json/blueprint.gleam", 867).
-spec decode7(
    fun((HAB, HAC, HAD, HAE, HAF, HAG, HAH) -> HAI),
    field_decoder(HAB),
    field_decoder(HAC),
    field_decoder(HAD),
    field_decoder(HAE),
    field_decoder(HAF),
    field_decoder(HAG),
    field_decoder(HAH)
) -> decoder(HAI).
decode7(Constructor, T1, T2, T3, T4, T5, T6, T7) ->
    {decoder,
        json@blueprint@dynamic:decode7(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2),
            erlang:element(2, T3),
            erlang:element(2, T4),
            erlang:element(2, T5),
            erlang:element(2, T6),
            erlang:element(2, T7)
        ),
        create_object_schema(
            [erlang:element(3, T1),
                erlang:element(3, T2),
                erlang:element(3, T3),
                erlang:element(3, T4),
                erlang:element(3, T5),
                erlang:element(3, T6),
                erlang:element(3, T7)]
        ),
        gleam@list:flatten(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4),
                erlang:element(4, T5),
                erlang:element(4, T6),
                erlang:element(4, T7)]
        )}.

-file("src/json/blueprint.gleam", 901).
-spec decode8(
    fun((HAR, HAS, HAT, HAU, HAV, HAW, HAX, HAY) -> HAZ),
    field_decoder(HAR),
    field_decoder(HAS),
    field_decoder(HAT),
    field_decoder(HAU),
    field_decoder(HAV),
    field_decoder(HAW),
    field_decoder(HAX),
    field_decoder(HAY)
) -> decoder(HAZ).
decode8(Constructor, T1, T2, T3, T4, T5, T6, T7, T8) ->
    {decoder,
        json@blueprint@dynamic:decode8(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2),
            erlang:element(2, T3),
            erlang:element(2, T4),
            erlang:element(2, T5),
            erlang:element(2, T6),
            erlang:element(2, T7),
            erlang:element(2, T8)
        ),
        create_object_schema(
            [erlang:element(3, T1),
                erlang:element(3, T2),
                erlang:element(3, T3),
                erlang:element(3, T4),
                erlang:element(3, T5),
                erlang:element(3, T6),
                erlang:element(3, T7),
                erlang:element(3, T8)]
        ),
        gleam@list:flatten(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4),
                erlang:element(4, T5),
                erlang:element(4, T6),
                erlang:element(4, T7),
                erlang:element(4, T8)]
        )}.

-file("src/json/blueprint.gleam", 947).
-spec decode9(
    fun((HBJ, HBK, HBL, HBM, HBN, HBO, HBP, HBQ, HBR) -> HBS),
    field_decoder(HBJ),
    field_decoder(HBK),
    field_decoder(HBL),
    field_decoder(HBM),
    field_decoder(HBN),
    field_decoder(HBO),
    field_decoder(HBP),
    field_decoder(HBQ),
    field_decoder(HBR)
) -> decoder(HBS).
decode9(Constructor, T1, T2, T3, T4, T5, T6, T7, T8, T9) ->
    {decoder,
        json@blueprint@dynamic:decode9(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2),
            erlang:element(2, T3),
            erlang:element(2, T4),
            erlang:element(2, T5),
            erlang:element(2, T6),
            erlang:element(2, T7),
            erlang:element(2, T8),
            erlang:element(2, T9)
        ),
        create_object_schema(
            [erlang:element(3, T1),
                erlang:element(3, T2),
                erlang:element(3, T3),
                erlang:element(3, T4),
                erlang:element(3, T5),
                erlang:element(3, T6),
                erlang:element(3, T7),
                erlang:element(3, T8),
                erlang:element(3, T9)]
        ),
        gleam@list:flatten(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4),
                erlang:element(4, T5),
                erlang:element(4, T6),
                erlang:element(4, T7),
                erlang:element(4, T8),
                erlang:element(4, T9)]
        )}.

-file("src/json/blueprint.gleam", 997).
-spec encode_tuple2(
    {HCD, HCE},
    fun((HCD) -> gleam@json:json()),
    fun((HCE) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple2(Tuple, Encode1, Encode2) ->
    {T1, T2} = Tuple,
    gleam@json:preprocessed_array([Encode1(T1), Encode2(T2)]).

-file("src/json/blueprint.gleam", 1006).
-spec encode_tuple3(
    {HCF, HCG, HCH},
    fun((HCF) -> gleam@json:json()),
    fun((HCG) -> gleam@json:json()),
    fun((HCH) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple3(Tuple, Encode1, Encode2, Encode3) ->
    {T1, T2, T3} = Tuple,
    gleam@json:preprocessed_array([Encode1(T1), Encode2(T2), Encode3(T3)]).

-file("src/json/blueprint.gleam", 1016).
-spec encode_tuple4(
    {HCI, HCJ, HCK, HCL},
    fun((HCI) -> gleam@json:json()),
    fun((HCJ) -> gleam@json:json()),
    fun((HCK) -> gleam@json:json()),
    fun((HCL) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple4(Tuple, Encode1, Encode2, Encode3, Encode4) ->
    {T1, T2, T3, T4} = Tuple,
    gleam@json:preprocessed_array(
        [Encode1(T1), Encode2(T2), Encode3(T3), Encode4(T4)]
    ).

-file("src/json/blueprint.gleam", 1027).
-spec encode_tuple5(
    {HCM, HCN, HCO, HCP, HCQ},
    fun((HCM) -> gleam@json:json()),
    fun((HCN) -> gleam@json:json()),
    fun((HCO) -> gleam@json:json()),
    fun((HCP) -> gleam@json:json()),
    fun((HCQ) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple5(Tuple, Encode1, Encode2, Encode3, Encode4, Encode5) ->
    {T1, T2, T3, T4, T5} = Tuple,
    gleam@json:preprocessed_array(
        [Encode1(T1), Encode2(T2), Encode3(T3), Encode4(T4), Encode5(T5)]
    ).

-file("src/json/blueprint.gleam", 1045).
-spec encode_tuple6(
    {HCR, HCS, HCT, HCU, HCV, HCW},
    fun((HCR) -> gleam@json:json()),
    fun((HCS) -> gleam@json:json()),
    fun((HCT) -> gleam@json:json()),
    fun((HCU) -> gleam@json:json()),
    fun((HCV) -> gleam@json:json()),
    fun((HCW) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple6(Tuple, Encode1, Encode2, Encode3, Encode4, Encode5, Encode6) ->
    {T1, T2, T3, T4, T5, T6} = Tuple,
    gleam@json:preprocessed_array(
        [Encode1(T1),
            Encode2(T2),
            Encode3(T3),
            Encode4(T4),
            Encode5(T5),
            Encode6(T6)]
    ).

-file("src/json/blueprint.gleam", 1065).
-spec encode_tuple7(
    {HCX, HCY, HCZ, HDA, HDB, HDC, HDD},
    fun((HCX) -> gleam@json:json()),
    fun((HCY) -> gleam@json:json()),
    fun((HCZ) -> gleam@json:json()),
    fun((HDA) -> gleam@json:json()),
    fun((HDB) -> gleam@json:json()),
    fun((HDC) -> gleam@json:json()),
    fun((HDD) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple7(
    Tuple,
    Encode1,
    Encode2,
    Encode3,
    Encode4,
    Encode5,
    Encode6,
    Encode7
) ->
    {T1, T2, T3, T4, T5, T6, T7} = Tuple,
    gleam@json:preprocessed_array(
        [Encode1(T1),
            Encode2(T2),
            Encode3(T3),
            Encode4(T4),
            Encode5(T5),
            Encode6(T6),
            Encode7(T7)]
    ).

-file("src/json/blueprint.gleam", 1087).
-spec encode_tuple8(
    {HDE, HDF, HDG, HDH, HDI, HDJ, HDK, HDL},
    fun((HDE) -> gleam@json:json()),
    fun((HDF) -> gleam@json:json()),
    fun((HDG) -> gleam@json:json()),
    fun((HDH) -> gleam@json:json()),
    fun((HDI) -> gleam@json:json()),
    fun((HDJ) -> gleam@json:json()),
    fun((HDK) -> gleam@json:json()),
    fun((HDL) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple8(
    Tuple,
    Encode1,
    Encode2,
    Encode3,
    Encode4,
    Encode5,
    Encode6,
    Encode7,
    Encode8
) ->
    {T1, T2, T3, T4, T5, T6, T7, T8} = Tuple,
    gleam@json:preprocessed_array(
        [Encode1(T1),
            Encode2(T2),
            Encode3(T3),
            Encode4(T4),
            Encode5(T5),
            Encode6(T6),
            Encode7(T7),
            Encode8(T8)]
    ).

-file("src/json/blueprint.gleam", 1111).
-spec encode_tuple9(
    {HDM, HDN, HDO, HDP, HDQ, HDR, HDS, HDT, HDU},
    fun((HDM) -> gleam@json:json()),
    fun((HDN) -> gleam@json:json()),
    fun((HDO) -> gleam@json:json()),
    fun((HDP) -> gleam@json:json()),
    fun((HDQ) -> gleam@json:json()),
    fun((HDR) -> gleam@json:json()),
    fun((HDS) -> gleam@json:json()),
    fun((HDT) -> gleam@json:json()),
    fun((HDU) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple9(
    Tuple,
    Encode1,
    Encode2,
    Encode3,
    Encode4,
    Encode5,
    Encode6,
    Encode7,
    Encode8,
    Encode9
) ->
    {T1, T2, T3, T4, T5, T6, T7, T8, T9} = Tuple,
    gleam@json:preprocessed_array(
        [Encode1(T1),
            Encode2(T2),
            Encode3(T3),
            Encode4(T4),
            Encode5(T5),
            Encode6(T6),
            Encode7(T7),
            Encode8(T8),
            Encode9(T9)]
    ).