-module(mochi@query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/mochi/query.gleam").
-export([with_encoder/2, with_guard/2, with_description/2, get_name/1, get_description/1, get_args/1, 'query'/3, query_with_args/4, mutation/3, mutation_with_args/4, subscription/3, subscription_with_args/4, field/4, field_with_args/5, all_of/1, any_of/1, arg/2, arg_with_desc/3, arg_with_default/3, arg_with_default_desc/4, get_string/2, get_id/2, get_int/2, get_float/2, get_bool/2, get_optional_string/2, get_optional_id/2, get_optional_int/2, get_optional_float/2, get_optional_bool/2, get_string_list/2, get_int_list/2, decode_input/3, get_dynamic/2, get_optional_dynamic/2, get_string_or/3, get_id_or/3, get_int_or/3, get_float_or/3, get_bool_or/3, to_field_def/1, new/0, add_query/2, add_mutation/2, add_subscription/2, add_type/2, add_enum/2, add_interface/2, add_union/2, add_scalar/2, add_input/2, add_queries/2, add_mutations/2, add_subscriptions/2, add_types/2, add_enums/2, add_interfaces/2, add_unions/2, add_scalars/2, add_inputs/2, with_common_scalars/1, merge/2, with_cache/1, build/1]).
-export_type([query_kind/0, mutation_kind/0, subscription_kind/0, field_kind/1, internal_resolver/1, op/2, arg_def/0, schema_builder/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.

-type query_kind() :: query_kind.

-type mutation_kind() :: mutation_kind.

-type subscription_kind() :: subscription_kind.

-opaque field_kind(MAG) :: {field_kind, fun((MAG) -> MAG)}.

-type internal_resolver(MAH) :: {simple_resolver,
        fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, MAH} |
            {error, mochi@error:graph_q_l_error()})} |
    {topic_resolver,
        fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok,
                binary()} |
            {error, mochi@error:graph_q_l_error()})} |
    {parent_resolver,
        fun((gleam@option:option(gleam@dynamic:dynamic_()), mochi@args:args(), mochi@schema:execution_context()) -> {ok,
                MAH} |
            {error, mochi@error:graph_q_l_error()})}.

-opaque op(MAI, MAJ) :: {op,
        binary(),
        gleam@option:option(binary()),
        internal_resolver(MAJ),
        fun((MAJ) -> gleam@dynamic:dynamic_()),
        list(arg_def()),
        mochi@schema:field_type(),
        list(fun((mochi@schema:execution_context()) -> {ok, nil} |
            {error, binary()})),
        MAI}.

-type arg_def() :: {arg_def,
        binary(),
        mochi@schema:field_type(),
        gleam@option:option(binary()),
        gleam@option:option(gleam@dynamic:dynamic_())}.

-opaque schema_builder() :: {schema_builder,
        list(mochi@schema:field_definition()),
        list(mochi@schema:field_definition()),
        list(mochi@schema:field_definition()),
        list(mochi@schema:object_type()),
        list(mochi@schema:enum_type()),
        list(mochi@schema:interface_type()),
        list(mochi@schema:union_type()),
        list(mochi@schema:scalar_type()),
        list(mochi@schema:input_object_type()),
        boolean()}.

-file("src/mochi/query.gleam", 101).
?DOC(" Override the result encoder. Works on any operation type.\n").
-spec with_encoder(op(MBA, MBB), fun((MBB) -> gleam@dynamic:dynamic_())) -> op(MBA, MBB).
with_encoder(Op, Encoder) ->
    {op,
        erlang:element(2, Op),
        erlang:element(3, Op),
        erlang:element(4, Op),
        Encoder,
        erlang:element(6, Op),
        erlang:element(7, Op),
        erlang:element(8, Op),
        erlang:element(9, Op)}.

-file("src/mochi/query.gleam", 106).
?DOC(" Add a guard. Works on any operation type. Guards run in the order added.\n").
-spec with_guard(
    op(MBG, MBH),
    fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})
) -> op(MBG, MBH).
with_guard(Op, Guard_fn) ->
    {op,
        erlang:element(2, Op),
        erlang:element(3, Op),
        erlang:element(4, Op),
        erlang:element(5, Op),
        erlang:element(6, Op),
        erlang:element(7, Op),
        lists:append(erlang:element(8, Op), [Guard_fn]),
        erlang:element(9, Op)}.

-file("src/mochi/query.gleam", 111).
?DOC(" Set the description. Works on any operation type.\n").
-spec with_description(op(MBM, MBN), binary()) -> op(MBM, MBN).
with_description(Op, Desc) ->
    {op,
        erlang:element(2, Op),
        {some, Desc},
        erlang:element(4, Op),
        erlang:element(5, Op),
        erlang:element(6, Op),
        erlang:element(7, Op),
        erlang:element(8, Op),
        erlang:element(9, Op)}.

-file("src/mochi/query.gleam", 119).
-spec get_name(op(any(), any())) -> binary().
get_name(Op) ->
    erlang:element(2, Op).

-file("src/mochi/query.gleam", 123).
-spec get_description(op(any(), any())) -> gleam@option:option(binary()).
get_description(Op) ->
    erlang:element(3, Op).

-file("src/mochi/query.gleam", 127).
-spec get_args(op(any(), any())) -> list(arg_def()).
get_args(Op) ->
    erlang:element(6, Op).

-file("src/mochi/query.gleam", 136).
?DOC(" Define a query with no arguments.\n").
-spec 'query'(
    binary(),
    mochi@schema:field_type(),
    fun((mochi@schema:execution_context()) -> {ok, MCG} |
        {error, mochi@error:graph_q_l_error()})
) -> op(query_kind(), MCG).
'query'(Name, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, fun(_, Ctx) -> Resolver(Ctx) end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        query_kind}.

-file("src/mochi/query.gleam", 154).
?DOC(" Define a query with arguments.\n").
-spec query_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, MCL} |
        {error, mochi@error:graph_q_l_error()})
) -> op(query_kind(), MCL).
query_with_args(Name, Arg_defs, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, Resolver},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        query_kind}.

-file("src/mochi/query.gleam", 176).
-spec mutation(
    binary(),
    mochi@schema:field_type(),
    fun((mochi@schema:execution_context()) -> {ok, MCP} |
        {error, mochi@error:graph_q_l_error()})
) -> op(mutation_kind(), MCP).
mutation(Name, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, fun(_, Ctx) -> Resolver(Ctx) end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        mutation_kind}.

-file("src/mochi/query.gleam", 193).
-spec mutation_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, MCU} |
        {error, mochi@error:graph_q_l_error()})
) -> op(mutation_kind(), MCU).
mutation_with_args(Name, Arg_defs, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, Resolver},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        mutation_kind}.

-file("src/mochi/query.gleam", 216).
?DOC(" Define a subscription with a static topic string.\n").
-spec subscription(binary(), mochi@schema:field_type(), binary()) -> op(subscription_kind(), any()).
subscription(Name, Return_type, Topic) ->
    {op,
        Name,
        none,
        {topic_resolver, fun(_, _) -> {ok, Topic} end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        subscription_kind}.

-file("src/mochi/query.gleam", 234).
?DOC(" Define a subscription with arguments and a dynamic topic resolver.\n").
-spec subscription_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, binary()} |
        {error, mochi@error:graph_q_l_error()})
) -> op(subscription_kind(), any()).
subscription_with_args(Name, Arg_defs, Return_type, Topic_resolver) ->
    {op,
        Name,
        none,
        {topic_resolver, Topic_resolver},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        subscription_kind}.

-file("src/mochi/query.gleam", 257).
?DOC(" Define a field on a type with no extra arguments.\n").
-spec field(
    binary(),
    mochi@schema:field_type(),
    fun((gleam@dynamic:dynamic_()) -> {ok, MDF} | {error, binary()}),
    fun((MDF, mochi@schema:execution_context()) -> {ok, MDI} |
        {error, mochi@error:graph_q_l_error()})
) -> op(field_kind(MDF), MDI).
field(Name, Return_type, Parent_decoder, Resolver) ->
    {op,
        Name,
        none,
        {parent_resolver,
            fun(Parent_dyn, _, Ctx) ->
                gleam@result:'try'(
                    gleam@option:to_result(
                        Parent_dyn,
                        mochi@error:new(<<"No parent value provided"/utf8>>)
                    ),
                    fun(Parent_dyn_val) ->
                        gleam@result:'try'(
                            begin
                                _pipe = Parent_decoder(Parent_dyn_val),
                                gleam@result:map_error(
                                    _pipe,
                                    fun(E) ->
                                        mochi@error:new(
                                            <<"Failed to decode parent: "/utf8,
                                                E/binary>>
                                        )
                                    end
                                )
                            end,
                            fun(P) -> Resolver(P, Ctx) end
                        )
                    end
                )
            end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        {field_kind, fun(X) -> X end}}.

-file("src/mochi/query.gleam", 288).
?DOC(" Define a field on a type with arguments.\n").
-spec field_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((gleam@dynamic:dynamic_()) -> {ok, MDO} | {error, binary()}),
    fun((MDO, mochi@args:args(), mochi@schema:execution_context()) -> {ok, MDR} |
        {error, mochi@error:graph_q_l_error()})
) -> op(field_kind(MDO), MDR).
field_with_args(Name, Arg_defs, Return_type, Parent_decoder, Resolver) ->
    {op,
        Name,
        none,
        {parent_resolver,
            fun(Parent_dyn, Args, Ctx) ->
                gleam@result:'try'(
                    gleam@option:to_result(
                        Parent_dyn,
                        mochi@error:new(<<"No parent value provided"/utf8>>)
                    ),
                    fun(Parent_dyn_val) ->
                        gleam@result:'try'(
                            begin
                                _pipe = Parent_decoder(Parent_dyn_val),
                                gleam@result:map_error(
                                    _pipe,
                                    fun(E) ->
                                        mochi@error:new(
                                            <<"Failed to decode parent: "/utf8,
                                                E/binary>>
                                        )
                                    end
                                )
                            end,
                            fun(P) -> Resolver(P, Args, Ctx) end
                        )
                    end
                )
            end},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        {field_kind, fun(X) -> X end}}.

-file("src/mochi/query.gleam", 328).
?DOC(" Combine guards with AND logic — all must pass (checked in list order).\n").
-spec all_of(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}))
) -> fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}).
all_of(Guard_fns) ->
    fun(Ctx) -> gleam@list:try_each(Guard_fns, fun(G) -> G(Ctx) end) end.

-file("src/mochi/query.gleam", 343).
-spec try_any(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    mochi@schema:execution_context(),
    binary()
) -> {ok, nil} | {error, binary()}.
try_any(Guards, Ctx, Last_error) ->
    case Guards of
        [] ->
            {error, Last_error};

        [G | Rest] ->
            case G(Ctx) of
                {ok, nil} ->
                    {ok, nil};

                {error, E} ->
                    try_any(Rest, Ctx, E)
            end
    end.

-file("src/mochi/query.gleam", 334).
?DOC(
    " Combine guards with OR logic — at least one must pass.\n"
    " Fails with the last error if all fail.\n"
).
-spec any_of(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}))
) -> fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}).
any_of(Guard_fns) ->
    fun(Ctx) -> case Guard_fns of
            [] ->
                {error, <<"No guards provided"/utf8>>};

            _ ->
                try_any(Guard_fns, Ctx, <<"No guards passed"/utf8>>)
        end end.

-file("src/mochi/query.gleam", 358).
-spec apply_gql_guards(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, MEC} |
        {error, mochi@error:graph_q_l_error()})
) -> fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, MEC} |
    {error, mochi@error:graph_q_l_error()}).
apply_gql_guards(Guards, Resolver) ->
    gleam@list:fold(
        lists:reverse(Guards),
        Resolver,
        fun(Inner, G) -> fun(Args, Ctx) -> case G(Ctx) of
                    {ok, nil} ->
                        Inner(Args, Ctx);

                    {error, Msg} ->
                        {error, mochi@error:new(Msg)}
                end end end
    ).

-file("src/mochi/query.gleam", 372).
-spec apply_topic_guards(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, binary()} |
        {error, mochi@error:graph_q_l_error()})
) -> fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, binary()} |
    {error, mochi@error:graph_q_l_error()}).
apply_topic_guards(Guards, Resolver) ->
    gleam@list:fold(
        lists:reverse(Guards),
        Resolver,
        fun(Inner, G) -> fun(Args, Ctx) -> case G(Ctx) of
                    {ok, nil} ->
                        Inner(Args, Ctx);

                    {error, Msg} ->
                        {error, mochi@error:new(Msg)}
                end end end
    ).

-file("src/mochi/query.gleam", 386).
-spec apply_parent_gql_guards(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    fun((gleam@option:option(gleam@dynamic:dynamic_()), mochi@args:args(), mochi@schema:execution_context()) -> {ok,
            MEO} |
        {error, mochi@error:graph_q_l_error()})
) -> fun((gleam@option:option(gleam@dynamic:dynamic_()), mochi@args:args(), mochi@schema:execution_context()) -> {ok,
        MEO} |
    {error, mochi@error:graph_q_l_error()}).
apply_parent_gql_guards(Guards, Resolver) ->
    gleam@list:fold(
        lists:reverse(Guards),
        Resolver,
        fun(Inner, G) -> fun(Parent, Args, Ctx) -> case G(Ctx) of
                    {ok, nil} ->
                        Inner(Parent, Args, Ctx);

                    {error, Msg} ->
                        {error, mochi@error:new(Msg)}
                end end end
    ).

-file("src/mochi/query.gleam", 406).
?DOC(" Create an argument definition\n").
-spec arg(binary(), mochi@schema:field_type()) -> arg_def().
arg(Name, Arg_type) ->
    {arg_def, Name, Arg_type, none, none}.

-file("src/mochi/query.gleam", 411).
?DOC(" Create an argument with description\n").
-spec arg_with_desc(binary(), mochi@schema:field_type(), binary()) -> arg_def().
arg_with_desc(Name, Arg_type, Description) ->
    {arg_def, Name, Arg_type, {some, Description}, none}.

-file("src/mochi/query.gleam", 425).
?DOC(" Create an argument with a default value\n").
-spec arg_with_default(
    binary(),
    mochi@schema:field_type(),
    gleam@dynamic:dynamic_()
) -> arg_def().
arg_with_default(Name, Arg_type, Default) ->
    {arg_def, Name, Arg_type, none, {some, Default}}.

-file("src/mochi/query.gleam", 439).
?DOC(" Create an argument with default value and description\n").
-spec arg_with_default_desc(
    binary(),
    mochi@schema:field_type(),
    gleam@dynamic:dynamic_(),
    binary()
) -> arg_def().
arg_with_default_desc(Name, Arg_type, Default, Description) ->
    {arg_def, Name, Arg_type, {some, Description}, {some, Default}}.

-file("src/mochi/query.gleam", 461).
-spec arg_to_gql(mochi@args:arg_error()) -> mochi@error:graph_q_l_error().
arg_to_gql(E) ->
    mochi@error:new(mochi@args:error_message(E)).

-file("src/mochi/query.gleam", 465).
-spec get_string(mochi@args:args(), binary()) -> {ok, binary()} |
    {error, mochi@error:graph_q_l_error()}.
get_string(Args, Key) ->
    _pipe = mochi@args:get_string(Args, Key),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 469).
-spec get_id(mochi@args:args(), binary()) -> {ok, binary()} |
    {error, mochi@error:graph_q_l_error()}.
get_id(Args, Key) ->
    _pipe = mochi@args:get_id(Args, Key),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 473).
-spec get_int(mochi@args:args(), binary()) -> {ok, integer()} |
    {error, mochi@error:graph_q_l_error()}.
get_int(Args, Key) ->
    _pipe = mochi@args:get_int(Args, Key),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 477).
-spec get_float(mochi@args:args(), binary()) -> {ok, float()} |
    {error, mochi@error:graph_q_l_error()}.
get_float(Args, Key) ->
    _pipe = mochi@args:get_float(Args, Key),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 481).
-spec get_bool(mochi@args:args(), binary()) -> {ok, boolean()} |
    {error, mochi@error:graph_q_l_error()}.
get_bool(Args, Key) ->
    _pipe = mochi@args:get_bool(Args, Key),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 485).
-spec get_optional_string(mochi@args:args(), binary()) -> gleam@option:option(binary()).
get_optional_string(Args, Key) ->
    mochi@args:get_optional_string(Args, Key).

-file("src/mochi/query.gleam", 489).
-spec get_optional_id(mochi@args:args(), binary()) -> gleam@option:option(binary()).
get_optional_id(Args, Key) ->
    mochi@args:get_optional_string(Args, Key).

-file("src/mochi/query.gleam", 493).
-spec get_optional_int(mochi@args:args(), binary()) -> gleam@option:option(integer()).
get_optional_int(Args, Key) ->
    mochi@args:get_optional_int(Args, Key).

-file("src/mochi/query.gleam", 497).
-spec get_optional_float(mochi@args:args(), binary()) -> gleam@option:option(float()).
get_optional_float(Args, Key) ->
    mochi@args:get_optional_float(Args, Key).

-file("src/mochi/query.gleam", 501).
-spec get_optional_bool(mochi@args:args(), binary()) -> gleam@option:option(boolean()).
get_optional_bool(Args, Key) ->
    mochi@args:get_optional_bool(Args, Key).

-file("src/mochi/query.gleam", 505).
-spec get_string_list(mochi@args:args(), binary()) -> {ok, list(binary())} |
    {error, mochi@error:graph_q_l_error()}.
get_string_list(Args, Key) ->
    _pipe = mochi@args:get_string_list(Args, Key),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 512).
-spec get_int_list(mochi@args:args(), binary()) -> {ok, list(integer())} |
    {error, mochi@error:graph_q_l_error()}.
get_int_list(Args, Key) ->
    _pipe = mochi@args:get_int_list(Args, Key),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 516).
-spec decode_input(
    mochi@args:args(),
    binary(),
    gleam@dynamic@decode:decoder(MFP)
) -> {ok, MFP} | {error, mochi@error:graph_q_l_error()}.
decode_input(Args, Key, Decoder) ->
    _pipe = mochi@args:decode_input(Args, Key, Decoder),
    gleam@result:map_error(_pipe, fun arg_to_gql/1).

-file("src/mochi/query.gleam", 524).
-spec get_dynamic(mochi@args:args(), binary()) -> {ok, gleam@dynamic:dynamic_()} |
    {error, mochi@error:graph_q_l_error()}.
get_dynamic(Args, Key) ->
    _pipe = gleam_stdlib:map_get(mochi@args:to_dict(Args), Key),
    gleam@result:map_error(
        _pipe,
        fun(_) ->
            mochi@error:new(<<"Missing required argument: "/utf8, Key/binary>>)
        end
    ).

-file("src/mochi/query.gleam", 529).
-spec get_optional_dynamic(mochi@args:args(), binary()) -> gleam@option:option(gleam@dynamic:dynamic_()).
get_optional_dynamic(Args, Key) ->
    _pipe = gleam_stdlib:map_get(mochi@args:to_dict(Args), Key),
    gleam@option:from_result(_pipe).

-file("src/mochi/query.gleam", 533).
-spec get_string_or(mochi@args:args(), binary(), binary()) -> binary().
get_string_or(Args, Key, Default) ->
    _pipe = mochi@args:get_optional_string(Args, Key),
    gleam@option:unwrap(_pipe, Default).

-file("src/mochi/query.gleam", 537).
-spec get_id_or(mochi@args:args(), binary(), binary()) -> binary().
get_id_or(Args, Key, Default) ->
    get_string_or(Args, Key, Default).

-file("src/mochi/query.gleam", 541).
-spec get_int_or(mochi@args:args(), binary(), integer()) -> integer().
get_int_or(Args, Key, Default) ->
    _pipe = mochi@args:get_optional_int(Args, Key),
    gleam@option:unwrap(_pipe, Default).

-file("src/mochi/query.gleam", 545).
-spec get_float_or(mochi@args:args(), binary(), float()) -> float().
get_float_or(Args, Key, Default) ->
    _pipe = mochi@args:get_optional_float(Args, Key),
    gleam@option:unwrap(_pipe, Default).

-file("src/mochi/query.gleam", 549).
-spec get_bool_or(mochi@args:args(), binary(), boolean()) -> boolean().
get_bool_or(Args, Key, Default) ->
    _pipe = mochi@args:get_optional_bool(Args, Key),
    gleam@option:unwrap(_pipe, Default).

-file("src/mochi/query.gleam", 557).
-spec build_gql_resolver(
    fun((mochi@args:args(), mochi@schema:execution_context()) -> {ok, MFW} |
        {error, mochi@error:graph_q_l_error()}),
    fun((MFW) -> gleam@dynamic:dynamic_())
) -> fun((mochi@schema:resolver_info()) -> {ok, gleam@dynamic:dynamic_()} |
    {error,
        {binary(),
            gleam@option:option(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()))}}).
build_gql_resolver(Resolver, Result_encoder) ->
    fun(Info) ->
        case Resolver(erlang:element(4, Info), erlang:element(5, Info)) of
            {error, Err} ->
                {error, mochi@error:to_payload(Err)};

            {ok, Res} ->
                {ok, Result_encoder(Res)}
        end
    end.

-file("src/mochi/query.gleam", 569).
-spec apply_desc(mochi@schema:field_definition(), gleam@option:option(binary())) -> mochi@schema:field_definition().
apply_desc(Field, Desc) ->
    case Desc of
        {some, D} ->
            mochi@schema:field_description(Field, D);

        none ->
            Field
    end.

-file("src/mochi/query.gleam", 621).
-spec add_args_to_field(mochi@schema:field_definition(), list(arg_def())) -> mochi@schema:field_definition().
add_args_to_field(Field, Args) ->
    gleam@list:fold(
        Args,
        Field,
        fun(F, A) ->
            Base_arg = mochi@schema:arg(
                erlang:element(2, A),
                erlang:element(3, A)
            ),
            With_desc = case erlang:element(4, A) of
                {some, Desc} ->
                    mochi@schema:arg_description(Base_arg, Desc);

                none ->
                    Base_arg
            end,
            Arg_def = case erlang:element(5, A) of
                {some, Default} ->
                    mochi@schema:default_value(With_desc, Default);

                none ->
                    With_desc
            end,
            mochi@schema:argument(F, Arg_def)
        end
    ).

-file("src/mochi/query.gleam", 577).
?DOC(" Convert any Op to a schema FieldDefinition.\n").
-spec to_field_def(op(any(), any())) -> mochi@schema:field_definition().
to_field_def(Op) ->
    Base = begin
        _pipe = mochi@schema:field_def(
            erlang:element(2, Op),
            erlang:element(7, Op)
        ),
        _pipe@1 = add_args_to_field(_pipe, erlang:element(6, Op)),
        apply_desc(_pipe@1, erlang:element(3, Op))
    end,
    case erlang:element(4, Op) of
        {simple_resolver, Resolver} ->
            mochi@schema:rich_resolver_fn(
                Base,
                build_gql_resolver(
                    apply_gql_guards(erlang:element(8, Op), Resolver),
                    erlang:element(5, Op)
                )
            );

        {topic_resolver, Resolver@1} ->
            Guarded_topic = apply_topic_guards(
                erlang:element(8, Op),
                Resolver@1
            ),
            _pipe@2 = Base,
            _pipe@3 = mochi@schema:resolver(
                _pipe@2,
                fun(_) ->
                    {error,
                        <<"Subscriptions must be executed through the subscription executor"/utf8>>}
                end
            ),
            (fun(Fd) ->
                {field_definition,
                    erlang:element(2, Fd),
                    erlang:element(3, Fd),
                    erlang:element(4, Fd),
                    erlang:element(5, Fd),
                    erlang:element(6, Fd),
                    erlang:element(7, Fd),
                    erlang:element(8, Fd),
                    {some, fun(Args, Ctx) -> _pipe@4 = Guarded_topic(Args, Ctx),
                            gleam@result:map_error(
                                _pipe@4,
                                fun(E) -> erlang:element(2, E) end
                            ) end},
                    erlang:element(10, Fd)}
            end)(_pipe@3);

        {parent_resolver, Resolver@2} ->
            Guarded = apply_parent_gql_guards(erlang:element(8, Op), Resolver@2),
            mochi@schema:rich_resolver_fn(
                Base,
                fun(Info) ->
                    case Guarded(
                        erlang:element(2, Info),
                        erlang:element(4, Info),
                        erlang:element(5, Info)
                    ) of
                        {error, Err} ->
                            {error, mochi@error:to_payload(Err)};

                        {ok, Res} ->
                            {ok, (erlang:element(5, Op))(Res)}
                    end
                end
            )
    end.

-file("src/mochi/query.gleam", 661).
-spec new() -> schema_builder().
new() ->
    {schema_builder, [], [], [], [], [], [], [], [], [], false}.

-file("src/mochi/query.gleam", 676).
-spec add_query(schema_builder(), op(query_kind(), any())) -> schema_builder().
add_query(Builder, Q) ->
    {schema_builder,
        [to_field_def(Q) | erlang:element(2, Builder)],
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 680).
-spec add_mutation(schema_builder(), op(mutation_kind(), any())) -> schema_builder().
add_mutation(Builder, M) ->
    {schema_builder,
        erlang:element(2, Builder),
        [to_field_def(M) | erlang:element(3, Builder)],
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 687).
-spec add_subscription(schema_builder(), op(subscription_kind(), any())) -> schema_builder().
add_subscription(Builder, S) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        [to_field_def(S) | erlang:element(4, Builder)],
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 697).
-spec add_type(schema_builder(), mochi@schema:object_type()) -> schema_builder().
add_type(Builder, T) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        [T | erlang:element(5, Builder)],
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 701).
-spec add_enum(schema_builder(), mochi@schema:enum_type()) -> schema_builder().
add_enum(Builder, E) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        [E | erlang:element(6, Builder)],
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 705).
-spec add_interface(schema_builder(), mochi@schema:interface_type()) -> schema_builder().
add_interface(Builder, I) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        [I | erlang:element(7, Builder)],
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 712).
-spec add_union(schema_builder(), mochi@schema:union_type()) -> schema_builder().
add_union(Builder, U) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        [U | erlang:element(8, Builder)],
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 716).
-spec add_scalar(schema_builder(), mochi@schema:scalar_type()) -> schema_builder().
add_scalar(Builder, S) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        [S | erlang:element(9, Builder)],
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 720).
-spec add_input(schema_builder(), mochi@schema:input_object_type()) -> schema_builder().
add_input(Builder, I) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        [I | erlang:element(10, Builder)],
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 727).
-spec add_queries(schema_builder(), list(op(query_kind(), any()))) -> schema_builder().
add_queries(Builder, Queries) ->
    gleam@list:fold(Queries, Builder, fun(B, Q) -> add_query(B, Q) end).

-file("src/mochi/query.gleam", 734).
-spec add_mutations(schema_builder(), list(op(mutation_kind(), any()))) -> schema_builder().
add_mutations(Builder, Mutations) ->
    gleam@list:fold(Mutations, Builder, fun(B, M) -> add_mutation(B, M) end).

-file("src/mochi/query.gleam", 741).
-spec add_subscriptions(schema_builder(), list(op(subscription_kind(), any()))) -> schema_builder().
add_subscriptions(Builder, Subscriptions) ->
    gleam@list:fold(
        Subscriptions,
        Builder,
        fun(B, S) -> add_subscription(B, S) end
    ).

-file("src/mochi/query.gleam", 748).
-spec add_types(schema_builder(), list(mochi@schema:object_type())) -> schema_builder().
add_types(Builder, Types) ->
    gleam@list:fold(Types, Builder, fun(B, T) -> add_type(B, T) end).

-file("src/mochi/query.gleam", 755).
-spec add_enums(schema_builder(), list(mochi@schema:enum_type())) -> schema_builder().
add_enums(Builder, Enums) ->
    gleam@list:fold(Enums, Builder, fun(B, E) -> add_enum(B, E) end).

-file("src/mochi/query.gleam", 762).
-spec add_interfaces(schema_builder(), list(mochi@schema:interface_type())) -> schema_builder().
add_interfaces(Builder, Interfaces) ->
    gleam@list:fold(Interfaces, Builder, fun(B, I) -> add_interface(B, I) end).

-file("src/mochi/query.gleam", 769).
-spec add_unions(schema_builder(), list(mochi@schema:union_type())) -> schema_builder().
add_unions(Builder, Unions) ->
    gleam@list:fold(Unions, Builder, fun(B, U) -> add_union(B, U) end).

-file("src/mochi/query.gleam", 776).
-spec add_scalars(schema_builder(), list(mochi@schema:scalar_type())) -> schema_builder().
add_scalars(Builder, Scalars) ->
    gleam@list:fold(Scalars, Builder, fun(B, S) -> add_scalar(B, S) end).

-file("src/mochi/query.gleam", 783).
-spec add_inputs(schema_builder(), list(mochi@schema:input_object_type())) -> schema_builder().
add_inputs(Builder, Inputs) ->
    gleam@list:fold(Inputs, Builder, fun(B, I) -> add_input(B, I) end).

-file("src/mochi/query.gleam", 791).
?DOC(" Register all built-in custom scalars (DateTime, Date, UUID, Email, URL, JSON).\n").
-spec with_common_scalars(schema_builder()) -> schema_builder().
with_common_scalars(Builder) ->
    add_scalars(
        Builder,
        [mochi@scalars:date_time(),
            mochi@scalars:date(),
            mochi@scalars:uuid(),
            mochi@scalars:email(),
            mochi@scalars:url(),
            mochi@scalars:json()]
    ).

-file("src/mochi/query.gleam", 802).
-spec check_duplicates(binary(), list(MHG), list(MHG), fun((MHG) -> binary())) -> nil.
check_duplicates(Label, A_items, B_items, Name_fn) ->
    A_names = gleam@list:map(A_items, Name_fn),
    Conflicts = gleam@list:filter(
        B_items,
        fun(Item) -> gleam@list:contains(A_names, Name_fn(Item)) end
    ),
    case Conflicts of
        [] ->
            nil;

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => (<<<<<<"Schema merge conflict: duplicate "/utf8,
                                Label/binary>>/binary,
                            " name(s): "/utf8>>/binary,
                        (gleam@string:join(
                            gleam@list:map(Conflicts, Name_fn),
                            <<", "/utf8>>
                        ))/binary>>),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"mochi/query"/utf8>>,
                    function => <<"check_duplicates"/utf8>>,
                    line => 814})
    end.

-file("src/mochi/query.gleam", 823).
-spec merge(schema_builder(), schema_builder()) -> schema_builder().
merge(A, B) ->
    check_duplicates(
        <<"query"/utf8>>,
        erlang:element(2, A),
        erlang:element(2, B),
        fun(F) -> erlang:element(2, F) end
    ),
    check_duplicates(
        <<"mutation"/utf8>>,
        erlang:element(3, A),
        erlang:element(3, B),
        fun(F@1) -> erlang:element(2, F@1) end
    ),
    check_duplicates(
        <<"subscription"/utf8>>,
        erlang:element(4, A),
        erlang:element(4, B),
        fun(F@2) -> erlang:element(2, F@2) end
    ),
    check_duplicates(
        <<"type"/utf8>>,
        erlang:element(5, A),
        erlang:element(5, B),
        fun(T) -> erlang:element(2, T) end
    ),
    check_duplicates(
        <<"enum"/utf8>>,
        erlang:element(6, A),
        erlang:element(6, B),
        fun(E) -> erlang:element(2, E) end
    ),
    check_duplicates(
        <<"interface"/utf8>>,
        erlang:element(7, A),
        erlang:element(7, B),
        fun(I) -> erlang:element(2, I) end
    ),
    check_duplicates(
        <<"union"/utf8>>,
        erlang:element(8, A),
        erlang:element(8, B),
        fun(U) -> erlang:element(2, U) end
    ),
    check_duplicates(
        <<"scalar"/utf8>>,
        erlang:element(9, A),
        erlang:element(9, B),
        fun(S) -> erlang:element(2, S) end
    ),
    check_duplicates(
        <<"input"/utf8>>,
        erlang:element(10, A),
        erlang:element(10, B),
        fun(I@1) -> erlang:element(2, I@1) end
    ),
    {schema_builder,
        lists:append(erlang:element(2, A), erlang:element(2, B)),
        lists:append(erlang:element(3, A), erlang:element(3, B)),
        lists:append(erlang:element(4, A), erlang:element(4, B)),
        lists:append(erlang:element(5, A), erlang:element(5, B)),
        lists:append(erlang:element(6, A), erlang:element(6, B)),
        lists:append(erlang:element(7, A), erlang:element(7, B)),
        lists:append(erlang:element(8, A), erlang:element(8, B)),
        lists:append(erlang:element(9, A), erlang:element(9, B)),
        lists:append(erlang:element(10, A), erlang:element(10, B)),
        erlang:element(11, A) orelse erlang:element(11, B)}.

-file("src/mochi/query.gleam", 849).
-spec with_cache(schema_builder()) -> schema_builder().
with_cache(Builder) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        true}.

-file("src/mochi/query.gleam", 853).
-spec build(schema_builder()) -> mochi@schema:schema().
build(Builder) ->
    Query_type = gleam@list:fold(
        erlang:element(2, Builder),
        mochi@schema:object(<<"Query"/utf8>>),
        fun(Obj, Field) -> mochi@schema:field(Obj, Field) end
    ),
    Base_schema = begin
        _pipe = mochi@schema:schema(),
        mochi@schema:'query'(_pipe, Query_type)
    end,
    With_mutation = case erlang:element(3, Builder) of
        [] ->
            Base_schema;

        _ ->
            Mutation_type = gleam@list:fold(
                erlang:element(3, Builder),
                mochi@schema:object(<<"Mutation"/utf8>>),
                fun(Obj@1, Field@1) -> mochi@schema:field(Obj@1, Field@1) end
            ),
            mochi@schema:mutation(Base_schema, Mutation_type)
    end,
    With_subscription = case erlang:element(4, Builder) of
        [] ->
            With_mutation;

        _ ->
            Subscription_type = gleam@list:fold(
                erlang:element(4, Builder),
                mochi@schema:object(<<"Subscription"/utf8>>),
                fun(Obj@2, Field@2) -> mochi@schema:field(Obj@2, Field@2) end
            ),
            mochi@schema:subscription(With_mutation, Subscription_type)
    end,
    With_types = gleam@list:fold(
        erlang:element(5, Builder),
        With_subscription,
        fun(S, T) -> mochi@schema:add_type(S, {object_type_def, T}) end
    ),
    With_enums = gleam@list:fold(
        erlang:element(6, Builder),
        With_types,
        fun(S@1, E) -> mochi@schema:add_type(S@1, {enum_type_def, E}) end
    ),
    With_interfaces = gleam@list:fold(
        erlang:element(7, Builder),
        With_enums,
        fun(S@2, I) -> mochi@schema:add_type(S@2, {interface_type_def, I}) end
    ),
    With_unions = gleam@list:fold(
        erlang:element(8, Builder),
        With_interfaces,
        fun(S@3, U) -> mochi@schema:add_type(S@3, {union_type_def, U}) end
    ),
    With_scalars = gleam@list:fold(
        erlang:element(9, Builder),
        With_unions,
        fun(S@4, Scalar) ->
            mochi@schema:add_type(S@4, {scalar_type_def, Scalar})
        end
    ),
    With_inputs = gleam@list:fold(
        erlang:element(10, Builder),
        With_scalars,
        fun(S@5, Input) ->
            mochi@schema:add_type(S@5, {input_object_type_def, Input})
        end
    ),
    With_directives = gleam@list:fold(
        mochi@schema:builtin_directives(),
        With_inputs,
        fun(S@6, Directive) -> mochi@schema:add_directive(S@6, Directive) end
    ),
    {schema,
        erlang:element(2, With_directives),
        erlang:element(3, With_directives),
        erlang:element(4, With_directives),
        erlang:element(5, With_directives),
        erlang:element(6, With_directives),
        {some, mochi@document_cache:new()}}.