-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, 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]).

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

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

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 28).
-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("/code/edgar/gleamplay/src/json/blueprint.gleam", 112).
-spec self_decoder(fun(() -> decoder(GKB))) -> decoder(GKB).
self_decoder(Lazy) ->
    {decoder,
        fun(Input) -> (erlang:element(2, Lazy()))(Input) end,
        {ref, <<"#"/utf8>>},
        []}.

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

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

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

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

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

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

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

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 71).
-spec reuse_decoder(decoder(GJY)) -> decoder(GJY).
reuse_decoder(Decoder) ->
    Ref_name = <<"ref_"/utf8,
        (json@blueprint@schema:hash_schema_definition(
            erlang:element(3, Decoder)
        ))/binary>>,
    {decoder,
        erlang:element(2, Decoder),
        {ref, <<"#/$defs/"/utf8, Ref_name/binary>>},
        begin
            _pipe = erlang:element(4, Decoder),
            gleam@list:prepend(_pipe, {Ref_name, erlang:element(3, Decoder)})
        end}.

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

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 181).
-spec optional(decoder(GKW)) -> decoder(gleam@option:option(GKW)).
optional(Decode) ->
    {decoder,
        gleam@dynamic:optional(erlang:element(2, Decode)),
        {nullable, erlang:element(3, Decode)},
        erlang:element(4, Decode)}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 217).
-spec optional_field(binary(), decoder(GLA)) -> field_decoder(gleam@option:option(GLA)).
optional_field(Name, Inner_type) ->
    {field_decoder,
        fun(Value) ->
            _pipe = (gleam@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("/code/edgar/gleamplay/src/json/blueprint.gleam", 264).
-spec union_type_encoder(GLE, fun((GLE) -> {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("/code/edgar/gleamplay/src/json/blueprint.gleam", 294).
-spec union_type_decoder(list({binary(), decoder(GLF)})) -> decoder(GLF).
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 = (gleam@dynamic:decode2(
            Constructor,
            gleam@dynamic:field(<<"type"/utf8>>, fun gleam@dynamic:string/1),
            gleam@dynamic:field(<<"data"/utf8>>, fun gleam@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
            ),
            {one_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("/code/edgar/gleamplay/src/json/blueprint.gleam", 390).
-spec enum_type_encoder(GLJ, fun((GLJ) -> 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("/code/edgar/gleamplay/src/json/blueprint.gleam", 419).
-spec enum_type_decoder(list({binary(), GLK})) -> decoder(GLK).
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 = (gleam@dynamic:decode1(
            Constructor,
            gleam@dynamic:field(<<"enum"/utf8>>, fun gleam@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("/code/edgar/gleamplay/src/json/blueprint.gleam", 462).
-spec map(decoder(GLN), fun((GLN) -> GLP)) -> decoder(GLP).
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("/code/edgar/gleamplay/src/json/blueprint.gleam", 470).
-spec tuple2(decoder(GLR), decoder(GLT)) -> decoder({GLR, GLT}).
tuple2(Decode1, Decode2) ->
    {decoder,
        gleam@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("/code/edgar/gleamplay/src/json/blueprint.gleam", 490).
-spec tuple3(decoder(GLW), decoder(GLY), decoder(GMA)) -> decoder({GLW,
    GLY,
    GMA}).
tuple3(Decode1, Decode2, Decode3) ->
    {decoder,
        gleam@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:concat(
            [erlang:element(4, Decode1),
                erlang:element(4, Decode2),
                erlang:element(4, Decode3)]
        )}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 515).
-spec tuple4(decoder(GMD), decoder(GMF), decoder(GMH), decoder(GMJ)) -> decoder({GMD,
    GMF,
    GMH,
    GMJ}).
tuple4(Decode1, Decode2, Decode3, Decode4) ->
    {decoder,
        gleam@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:concat(
            [erlang:element(4, Decode1),
                erlang:element(4, Decode2),
                erlang:element(4, Decode3),
                erlang:element(4, Decode4)]
        )}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 542).
-spec tuple5(
    decoder(GMM),
    decoder(GMO),
    decoder(GMQ),
    decoder(GMS),
    decoder(GMU)
) -> decoder({GMM, GMO, GMQ, GMS, GMU}).
tuple5(Decode1, Decode2, Decode3, Decode4, Decode5) ->
    {decoder,
        gleam@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:concat(
            [erlang:element(4, Decode1),
                erlang:element(4, Decode2),
                erlang:element(4, Decode3),
                erlang:element(4, Decode4),
                erlang:element(4, Decode5)]
        )}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 583).
-spec tuple6(
    decoder(GMX),
    decoder(GMZ),
    decoder(GNB),
    decoder(GND),
    decoder(GNF),
    decoder(GNH)
) -> decoder({GMX, GMZ, GNB, GND, GNF, GNH}).
tuple6(Decode1, Decode2, Decode3, Decode4, Decode5, Decode6) ->
    {decoder,
        gleam@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:concat(
            [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("/code/edgar/gleamplay/src/json/blueprint.gleam", 628).
-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("/code/edgar/gleamplay/src/json/blueprint.gleam", 645).
-spec decode0(GNL) -> decoder(GNL).
decode0(Constructor) ->
    {decoder,
        fun(_) -> {ok, Constructor} end,
        {object, [], {some, false}, none},
        []}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 672).
-spec decode1(fun((GNN) -> GNO), field_decoder(GNN)) -> decoder(GNO).
decode1(Constructor, T1) ->
    {decoder,
        gleam@dynamic:decode1(Constructor, erlang:element(2, T1)),
        create_object_schema([erlang:element(3, T1)]),
        erlang:element(4, T1)}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 680).
-spec decode2(fun((GNR, GNS) -> GNT), field_decoder(GNR), field_decoder(GNS)) -> decoder(GNT).
decode2(Constructor, T1, T2) ->
    {decoder,
        gleam@dynamic:decode2(
            Constructor,
            erlang:element(2, T1),
            erlang:element(2, T2)
        ),
        create_object_schema([erlang:element(3, T1), erlang:element(3, T2)]),
        gleam@list:concat([erlang:element(4, T1), erlang:element(4, T2)])}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 692).
-spec decode3(
    fun((GNX, GNY, GNZ) -> GOA),
    field_decoder(GNX),
    field_decoder(GNY),
    field_decoder(GNZ)
) -> decoder(GOA).
decode3(Constructor, T1, T2, T3) ->
    {decoder,
        gleam@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:concat(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3)]
        )}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 705).
-spec decode4(
    fun((GOF, GOG, GOH, GOI) -> GOJ),
    field_decoder(GOF),
    field_decoder(GOG),
    field_decoder(GOH),
    field_decoder(GOI)
) -> decoder(GOJ).
decode4(Constructor, T1, T2, T3, T4) ->
    {decoder,
        gleam@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:concat(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4)]
        )}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 730).
-spec decode5(
    fun((GOP, GOQ, GOR, GOS, GOT) -> GOU),
    field_decoder(GOP),
    field_decoder(GOQ),
    field_decoder(GOR),
    field_decoder(GOS),
    field_decoder(GOT)
) -> decoder(GOU).
decode5(Constructor, T1, T2, T3, T4, T5) ->
    {decoder,
        gleam@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:concat(
            [erlang:element(4, T1),
                erlang:element(4, T2),
                erlang:element(4, T3),
                erlang:element(4, T4),
                erlang:element(4, T5)]
        )}.

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 758).
-spec decode6(
    fun((GPB, GPC, GPD, GPE, GPF, GPG) -> GPH),
    field_decoder(GPB),
    field_decoder(GPC),
    field_decoder(GPD),
    field_decoder(GPE),
    field_decoder(GPF),
    field_decoder(GPG)
) -> decoder(GPH).
decode6(Constructor, T1, T2, T3, T4, T5, T6) ->
    {decoder,
        gleam@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:concat(
            [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("/code/edgar/gleamplay/src/json/blueprint.gleam", 789).
-spec decode7(
    fun((GPP, GPQ, GPR, GPS, GPT, GPU, GPV) -> GPW),
    field_decoder(GPP),
    field_decoder(GPQ),
    field_decoder(GPR),
    field_decoder(GPS),
    field_decoder(GPT),
    field_decoder(GPU),
    field_decoder(GPV)
) -> decoder(GPW).
decode7(Constructor, T1, T2, T3, T4, T5, T6, T7) ->
    {decoder,
        gleam@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:concat(
            [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("/code/edgar/gleamplay/src/json/blueprint.gleam", 823).
-spec decode8(
    fun((GQF, GQG, GQH, GQI, GQJ, GQK, GQL, GQM) -> GQN),
    field_decoder(GQF),
    field_decoder(GQG),
    field_decoder(GQH),
    field_decoder(GQI),
    field_decoder(GQJ),
    field_decoder(GQK),
    field_decoder(GQL),
    field_decoder(GQM)
) -> decoder(GQN).
decode8(Constructor, T1, T2, T3, T4, T5, T6, T7, T8) ->
    {decoder,
        gleam@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:concat(
            [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("/code/edgar/gleamplay/src/json/blueprint.gleam", 869).
-spec decode9(
    fun((GQX, GQY, GQZ, GRA, GRB, GRC, GRD, GRE, GRF) -> GRG),
    field_decoder(GQX),
    field_decoder(GQY),
    field_decoder(GQZ),
    field_decoder(GRA),
    field_decoder(GRB),
    field_decoder(GRC),
    field_decoder(GRD),
    field_decoder(GRE),
    field_decoder(GRF)
) -> decoder(GRG).
decode9(Constructor, T1, T2, T3, T4, T5, T6, T7, T8, T9) ->
    {decoder,
        gleam@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:concat(
            [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("/code/edgar/gleamplay/src/json/blueprint.gleam", 919).
-spec encode_tuple2(
    {GRR, GRS},
    fun((GRR) -> gleam@json:json()),
    fun((GRS) -> gleam@json:json())
) -> gleam@json:json().
encode_tuple2(Tuple, Encode1, Encode2) ->
    {T1, T2} = Tuple,
    gleam@json:preprocessed_array([Encode1(T1), Encode2(T2)]).

-file("/code/edgar/gleamplay/src/json/blueprint.gleam", 928).
-spec encode_tuple3(
    {GRT, GRU, GRV},
    fun((GRT) -> gleam@json:json()),
    fun((GRU) -> gleam@json:json()),
    fun((GRV) -> 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("/code/edgar/gleamplay/src/json/blueprint.gleam", 938).
-spec encode_tuple4(
    {GRW, GRX, GRY, GRZ},
    fun((GRW) -> gleam@json:json()),
    fun((GRX) -> gleam@json:json()),
    fun((GRY) -> gleam@json:json()),
    fun((GRZ) -> 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("/code/edgar/gleamplay/src/json/blueprint.gleam", 949).
-spec encode_tuple5(
    {GSA, GSB, GSC, GSD, GSE},
    fun((GSA) -> gleam@json:json()),
    fun((GSB) -> gleam@json:json()),
    fun((GSC) -> gleam@json:json()),
    fun((GSD) -> gleam@json:json()),
    fun((GSE) -> 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("/code/edgar/gleamplay/src/json/blueprint.gleam", 967).
-spec encode_tuple6(
    {GSF, GSG, GSH, GSI, GSJ, GSK},
    fun((GSF) -> gleam@json:json()),
    fun((GSG) -> gleam@json:json()),
    fun((GSH) -> gleam@json:json()),
    fun((GSI) -> gleam@json:json()),
    fun((GSJ) -> gleam@json:json()),
    fun((GSK) -> 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("/code/edgar/gleamplay/src/json/blueprint.gleam", 987).
-spec encode_tuple7(
    {GSL, GSM, GSN, GSO, GSP, GSQ, GSR},
    fun((GSL) -> gleam@json:json()),
    fun((GSM) -> gleam@json:json()),
    fun((GSN) -> gleam@json:json()),
    fun((GSO) -> gleam@json:json()),
    fun((GSP) -> gleam@json:json()),
    fun((GSQ) -> gleam@json:json()),
    fun((GSR) -> 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("/code/edgar/gleamplay/src/json/blueprint.gleam", 1009).
-spec encode_tuple8(
    {GSS, GST, GSU, GSV, GSW, GSX, GSY, GSZ},
    fun((GSS) -> gleam@json:json()),
    fun((GST) -> gleam@json:json()),
    fun((GSU) -> gleam@json:json()),
    fun((GSV) -> gleam@json:json()),
    fun((GSW) -> gleam@json:json()),
    fun((GSX) -> gleam@json:json()),
    fun((GSY) -> gleam@json:json()),
    fun((GSZ) -> 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("/code/edgar/gleamplay/src/json/blueprint.gleam", 1033).
-spec encode_tuple9(
    {GTA, GTB, GTC, GTD, GTE, GTF, GTG, GTH, GTI},
    fun((GTA) -> gleam@json:json()),
    fun((GTB) -> gleam@json:json()),
    fun((GTC) -> gleam@json:json()),
    fun((GTD) -> gleam@json:json()),
    fun((GTE) -> gleam@json:json()),
    fun((GTF) -> gleam@json:json()),
    fun((GTG) -> gleam@json:json()),
    fun((GTH) -> gleam@json:json()),
    fun((GTI) -> 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)]
    ).