dagger_gleam

-module(dagger@dsl@generator).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/generator.gleam").
-export([generator/1, changes/1, completed/3, description/3, id/1, is_empty/3, name/3, original_module/1, path/3, run/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.

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

-file("src/dagger/dsl/generator.gleam", 15).
?DOC(" The generated changeset\n").
-spec changes(dagger@dsl@types:generator()) -> dagger@dsl@types:changeset().
changes(Parent) ->
    Field = {field, <<"changes"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {changeset, New_op}.

-file("src/dagger/dsl/generator.gleam", 25).
?DOC(" Whether the generator complete\n").
-spec completed(
    dagger@dsl@types:generator(),
    dagger@types:client(),
    fun(({ok, boolean()} | {error, dagger@types:query_error()}) -> YKK)
) -> YKK.
completed(Parent, Client, Handler) ->
    Field = {field, <<"completed"/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_bool/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/generator.gleam", 46).
?DOC(" Return the description of the generator\n").
-spec description(
    dagger@dsl@types:generator(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> YKM)
) -> YKM.
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/generator.gleam", 67).
?DOC(" A unique identifier for this Generator.\n").
-spec id(dagger@dsl@types:generator()) -> dagger@dsl@types:generator().
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,
    {generator, New_op}.

-file("src/dagger/dsl/generator.gleam", 77).
?DOC(" Wether changeset from the generator execution is empty or not\n").
-spec is_empty(
    dagger@dsl@types:generator(),
    dagger@types:client(),
    fun(({ok, boolean()} | {error, dagger@types:query_error()}) -> YKO)
) -> YKO.
is_empty(Parent, Client, Handler) ->
    Field = {field, <<"isEmpty"/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_bool/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/generator.gleam", 98).
?DOC(" Return the fully qualified name of the generator\n").
-spec name(
    dagger@dsl@types:generator(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> YKQ)
) -> YKQ.
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/generator.gleam", 119).
?DOC(" The original module in which the generator has been defined\n").
-spec original_module(dagger@dsl@types:generator()) -> dagger@dsl@types:module_().
original_module(Parent) ->
    Field = {field, <<"originalModule"/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/generator.gleam", 129).
?DOC(" The path of the generator within its module\n").
-spec path(
    dagger@dsl@types:generator(),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> YKT)
) -> YKT.
path(Parent, Client, Handler) ->
    Field = {field, <<"path"/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,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                )
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

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