-module(dagger@dsl@module).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/module.gleam").
-export([none/1, opt_include/2, opt_include_dependencies/2, module/1, check/2, checks/2, dependencies/4, description/3, enums/4, generated_context_directory/1, generator/2, generators/2, id/1, interfaces/4, introspection_schema_j_s_o_n/1, name/3, objects/4, runtime/1, sdk/1, serve/4, source/1, sync/1, user_defaults/1, with_description/2, with_enum/2, with_interface/2, with_object/2]).
-export_type([for_serve/0, opts/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 for_serve() :: any().

-opaque opts(ACTE) :: {opts,
        gleam@option:option(list(binary())),
        gleam@option:option(boolean())} |
    {gleam_phantom, ACTE}.

-file("src/dagger/dsl/module.gleam", 19).
-spec defaults() -> opts(any()).
defaults() ->
    {opts, none, none}.

-file("src/dagger/dsl/module.gleam", 26).
-spec none(opts(ACTH)) -> opts(ACTH).
none(Opts) ->
    Opts.

-file("src/dagger/dsl/module.gleam", 30).
-spec opt_include(opts(ACTK), list(binary())) -> opts(ACTK).
opt_include(Opts, Val) ->
    {opts, {some, Val}, erlang:element(3, Opts)}.

-file("src/dagger/dsl/module.gleam", 34).
-spec opt_include_dependencies(opts(for_serve()), boolean()) -> opts(for_serve()).
opt_include_dependencies(Opts, Val) ->
    {opts, erlang:element(2, Opts), {some, Val}}.

-file("src/dagger/dsl/module.gleam", 38).
-spec module(dagger@dsl@types:module_()) -> dagger@dsl@types:module_().
module(Id) ->
    Field = {field,
        <<"loadModuleFromID"/utf8>>,
        [{<<"id"/utf8>>, {g_deferred, erlang:element(2, Id)}}],
        []},
    {module, {pure, [Field]}}.

-file("src/dagger/dsl/module.gleam", 44).
?DOC(" Return the check defined by the module with the given name. Must match to exactly one check.\n").
-spec check(dagger@dsl@types:module_(), binary()) -> dagger@dsl@types:check().
check(Parent, Name) ->
    Field = {field, <<"check"/utf8>>, [{<<"name"/utf8>>, {g_string, Name}}], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {check, New_op}.

-file("src/dagger/dsl/module.gleam", 53).
-spec encode_checks(opts(any())) -> list({binary(), dagger@types:value()}).
encode_checks(Opts) ->
    gleam@list:filter_map([case erlang:element(2, Opts) of
                {some, Val} ->
                    {ok,
                        {<<"include"/utf8>>,
                            {g_list,
                                gleam@list:map(Val, fun(X) -> {g_string, X} end)}}};

                none ->
                    {error, nil}
            end], fun(X@1) -> X@1 end).

-file("src/dagger/dsl/module.gleam", 63).
?DOC(" Return all checks defined by the module\n").
-spec checks(dagger@dsl@types:module_(), fun((opts(ACTT)) -> opts(ACTT))) -> dagger@dsl@types:check_group().
checks(Parent, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"checks"/utf8>>, encode_checks(Opts), []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {check_group, New_op}.

-file("src/dagger/dsl/module.gleam", 74).
?DOC(" The dependencies of the module.\n").
-spec dependencies(
    dagger@dsl@types:module_(),
    fun((dagger@dsl@types:module_()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:module_())} |
        {error, dagger@types:query_error()}) -> ACTZ)
) -> ACTZ.
dependencies(Parent, Select, Client, Handler) ->
    Subfields = Select({module, {pure, []}}),
    Field = {field, <<"dependencies"/utf8>>, [], Subfields},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_dynamic/1}
                                )
                            )
                        ) of
                            {ok, Items} ->
                                {pure,
                                    {ok,
                                        gleam@list:map(
                                            Items,
                                            fun(_) ->
                                                {module, {pure, Full_query}}
                                            end
                                        )}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error,
                                            <<"dependencies"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/module.gleam", 96).
?DOC(" The doc string of the module, if any\n").
-spec description(
    dagger@dsl@types:module_(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> ACUB)
) -> ACUB.
description(Parent, Client, Handler) ->
    Field = {field, <<"description"/utf8>>, [], []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error, <<"description"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/module.gleam", 117).
?DOC(" Enumerations served by this module.\n").
-spec enums(
    dagger@dsl@types:module_(),
    fun((dagger@dsl@types:type_def()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:type_def())} |
        {error, dagger@types:query_error()}) -> ACUF)
) -> ACUF.
enums(Parent, Select, Client, Handler) ->
    Subfields = Select({type_def, {pure, []}}),
    Field = {field, <<"enums"/utf8>>, [], Subfields},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_dynamic/1}
                                )
                            )
                        ) of
                            {ok, Items} ->
                                {pure,
                                    {ok,
                                        gleam@list:map(
                                            Items,
                                            fun(_) ->
                                                {type_def, {pure, Full_query}}
                                            end
                                        )}};

                            {error, _} ->
                                {pure,
                                    {error, {decoding_error, <<"enums"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/module.gleam", 139).
?DOC(" The generated files and directories made on top of the module source's context directory.\n").
-spec generated_context_directory(dagger@dsl@types:module_()) -> dagger@dsl@types:directory().
generated_context_directory(Parent) ->
    Field = {field, <<"generatedContextDirectory"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {directory, New_op}.

-file("src/dagger/dsl/module.gleam", 149).
?DOC(" Return the generator defined by the module with the given name. Must match to exactly one generator.\n").
-spec generator(dagger@dsl@types:module_(), binary()) -> dagger@dsl@types:generator().
generator(Parent, Name) ->
    Field = {field,
        <<"generator"/utf8>>,
        [{<<"name"/utf8>>, {g_string, Name}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {generator, New_op}.

-file("src/dagger/dsl/module.gleam", 158).
-spec encode_generators(opts(any())) -> list({binary(), dagger@types:value()}).
encode_generators(Opts) ->
    gleam@list:filter_map([case erlang:element(2, Opts) of
                {some, Val} ->
                    {ok,
                        {<<"include"/utf8>>,
                            {g_list,
                                gleam@list:map(Val, fun(X) -> {g_string, X} end)}}};

                none ->
                    {error, nil}
            end], fun(X@1) -> X@1 end).

-file("src/dagger/dsl/module.gleam", 168).
?DOC(" Return all generators defined by the module\n").
-spec generators(dagger@dsl@types:module_(), fun((opts(ACUJ)) -> opts(ACUJ))) -> dagger@dsl@types:generator_group().
generators(Parent, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"generators"/utf8>>, encode_generators(Opts), []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {generator_group, New_op}.

-file("src/dagger/dsl/module.gleam", 179).
?DOC(" A unique identifier for this Module.\n").
-spec id(dagger@dsl@types:module_()) -> dagger@dsl@types:module_().
id(Parent) ->
    Field = {field, <<"id"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {module, New_op}.

-file("src/dagger/dsl/module.gleam", 189).
?DOC(" Interfaces served by this module.\n").
-spec interfaces(
    dagger@dsl@types:module_(),
    fun((dagger@dsl@types:type_def()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:type_def())} |
        {error, dagger@types:query_error()}) -> ACUP)
) -> ACUP.
interfaces(Parent, Select, Client, Handler) ->
    Subfields = Select({type_def, {pure, []}}),
    Field = {field, <<"interfaces"/utf8>>, [], Subfields},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_dynamic/1}
                                )
                            )
                        ) of
                            {ok, Items} ->
                                {pure,
                                    {ok,
                                        gleam@list:map(
                                            Items,
                                            fun(_) ->
                                                {type_def, {pure, Full_query}}
                                            end
                                        )}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error, <<"interfaces"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/module.gleam", 213).
?DOC(
    " The introspection schema JSON file for this module.\n"
    " This file represents the schema visible to the module's source code, including all core types and those from the dependencies.\n"
    " Note: this is in the context of a module, so some core types may be hidden.\n"
).
-spec introspection_schema_j_s_o_n(dagger@dsl@types:module_()) -> dagger@dsl@types:file().
introspection_schema_j_s_o_n(Parent) ->
    Field = {field, <<"introspectionSchemaJSON"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {file, New_op}.

-file("src/dagger/dsl/module.gleam", 223).
?DOC(" The name of the module\n").
-spec name(
    dagger@dsl@types:module_(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> ACUR)
) -> ACUR.
name(Parent, Client, Handler) ->
    Field = {field, <<"name"/utf8>>, [], []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

                            {error, _} ->
                                {pure,
                                    {error, {decoding_error, <<"name"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/module.gleam", 244).
?DOC(" Objects served by this module.\n").
-spec objects(
    dagger@dsl@types:module_(),
    fun((dagger@dsl@types:type_def()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:type_def())} |
        {error, dagger@types:query_error()}) -> ACUV)
) -> ACUV.
objects(Parent, Select, Client, Handler) ->
    Subfields = Select({type_def, {pure, []}}),
    Field = {field, <<"objects"/utf8>>, [], Subfields},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_dynamic/1}
                                )
                            )
                        ) of
                            {ok, Items} ->
                                {pure,
                                    {ok,
                                        gleam@list:map(
                                            Items,
                                            fun(_) ->
                                                {type_def, {pure, Full_query}}
                                            end
                                        )}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error, <<"objects"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/module.gleam", 266).
?DOC(" The container that runs the module's entrypoint. It will fail to execute if the module doesn't compile.\n").
-spec runtime(dagger@dsl@types:module_()) -> dagger@dsl@types:container().
runtime(Parent) ->
    Field = {field, <<"runtime"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {container, New_op}.

-file("src/dagger/dsl/module.gleam", 276).
?DOC(" The SDK config used by this module.\n").
-spec sdk(dagger@dsl@types:module_()) -> dagger@dsl@types:s_d_k_config().
sdk(Parent) ->
    Field = {field, <<"sdk"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {s_d_k_config, New_op}.

-file("src/dagger/dsl/module.gleam", 285).
-spec encode_serve(opts(any())) -> list({binary(), dagger@types:value()}).
encode_serve(Opts) ->
    gleam@list:filter_map([case erlang:element(3, Opts) of
                {some, Val} ->
                    {ok, {<<"includeDependencies"/utf8>>, {g_bool, Val}}};

                none ->
                    {error, nil}
            end], fun(X) -> X end).

-file("src/dagger/dsl/module.gleam", 296).
?DOC(
    " Serve a module's API in the current session.\n"
    " Note: this can only be called once per session. In the future, it could return a stream or service to remove the side effect.\n"
).
-spec serve(
    dagger@dsl@types:module_(),
    fun((opts(for_serve())) -> opts(for_serve())),
    dagger@types:client(),
    fun(({ok, nil} | {error, dagger@types:query_error()}) -> ACVC)
) -> ACVC.
serve(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"serve"/utf8>>, encode_serve(Opts), []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_dynamic/1}
                            )
                        ) of
                            {ok, _} ->
                                {pure, {ok, nil}};

                            {error, _} ->
                                {pure,
                                    {error, {decoding_error, <<"serve"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/module.gleam", 318).
?DOC(" The source for the module.\n").
-spec source(dagger@dsl@types:module_()) -> dagger@dsl@types:module_source().
source(Parent) ->
    Field = {field, <<"source"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {module_source, New_op}.

-file("src/dagger/dsl/module.gleam", 328).
?DOC(" Forces evaluation of the module, including any loading into the engine and associated validation.\n").
-spec sync(dagger@dsl@types:module_()) -> dagger@dsl@types:module_().
sync(Parent) ->
    Field = {field, <<"sync"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {module, New_op}.

-file("src/dagger/dsl/module.gleam", 338).
?DOC(" User-defined default values, loaded from local .env files.\n").
-spec user_defaults(dagger@dsl@types:module_()) -> dagger@dsl@types:env_file().
user_defaults(Parent) ->
    Field = {field, <<"userDefaults"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {env_file, New_op}.

-file("src/dagger/dsl/module.gleam", 348).
?DOC(" Retrieves the module with the given description\n").
-spec with_description(dagger@dsl@types:module_(), binary()) -> dagger@dsl@types:module_().
with_description(Parent, Description) ->
    Field = {field,
        <<"withDescription"/utf8>>,
        [{<<"description"/utf8>>, {g_string, Description}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {module, New_op}.

-file("src/dagger/dsl/module.gleam", 358).
?DOC(" This module plus the given Enum type and associated values\n").
-spec with_enum(dagger@dsl@types:module_(), dagger@dsl@types:type_def()) -> dagger@dsl@types:module_().
with_enum(Parent, Enum) ->
    Field = {field,
        <<"withEnum"/utf8>>,
        [{<<"enum"/utf8>>, {g_deferred, erlang:element(2, Enum)}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {module, New_op}.

-file("src/dagger/dsl/module.gleam", 368).
?DOC(" This module plus the given Interface type and associated functions\n").
-spec with_interface(dagger@dsl@types:module_(), dagger@dsl@types:type_def()) -> dagger@dsl@types:module_().
with_interface(Parent, Iface) ->
    Field = {field,
        <<"withInterface"/utf8>>,
        [{<<"iface"/utf8>>, {g_deferred, erlang:element(2, Iface)}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {module, New_op}.

-file("src/dagger/dsl/module.gleam", 378).
?DOC(" This module plus the given Object type and associated functions.\n").
-spec with_object(dagger@dsl@types:module_(), dagger@dsl@types:type_def()) -> dagger@dsl@types:module_().
with_object(Parent, Object) ->
    Field = {field,
        <<"withObject"/utf8>>,
        [{<<"object"/utf8>>, {g_deferred, erlang:element(2, Object)}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {module, New_op}.