-module(dagger@dsl@function_call).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/function_call.gleam").
-export([function_call/0, function_call_id/1, input_args/4, function_call_name/3, parent/3, parent_name/3, return_error/4, return_value/4, function_call_arg_value/1, function_call_arg_value_id/1, function_call_arg_value_name/3, value/3]).

-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/function_call.gleam", 9).
-spec function_call() -> dagger@dsl@types:function_call().
function_call() ->
    Field = {field, <<"currentFunctionCall"/utf8>>, [], []},
    {function_call, {pure, [Field]}}.

-file("src/dagger/dsl/function_call.gleam", 15).
?DOC(" A unique identifier for this FunctionCall.\n").
-spec function_call_id(dagger@dsl@types:function_call()) -> dagger@dsl@types:function_call().
function_call_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,
    {function_call, New_op}.

-file("src/dagger/dsl/function_call.gleam", 25).
?DOC(" The argument values the function is being invoked with.\n").
-spec input_args(
    dagger@dsl@types:function_call(),
    fun((dagger@dsl@types:function_call_arg_value()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:function_call_arg_value())} |
        {error, dagger@types:query_error()}) -> XXI)
) -> XXI.
input_args(Parent, Select, Client, Handler) ->
    Subfields = Select({function_call_arg_value, {pure, []}}),
    Field = {field, <<"inputArgs"/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(_) ->
                                                {function_call_arg_value,
                                                    {pure, Full_query}}
                                            end
                                        )}};

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

-file("src/dagger/dsl/function_call.gleam", 47).
?DOC(" The name of the function being called.\n").
-spec function_call_name(
    dagger@dsl@types:function_call(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XXK)
) -> XXK.
function_call_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/function_call.gleam", 68).
?DOC(" The value of the parent object of the function being called. If the function is top-level to the module, this is always an empty object.\n").
-spec parent(
    dagger@dsl@types:function_call(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XXM)
) -> XXM.
parent(Parent, Client, Handler) ->
    Field = {field, <<"parent"/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, <<"parent"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_call.gleam", 89).
?DOC(" The name of the parent object of the function being called. If the function is top-level to the module, this is the name of the module.\n").
-spec parent_name(
    dagger@dsl@types:function_call(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XXO)
) -> XXO.
parent_name(Parent, Client, Handler) ->
    Field = {field, <<"parentName"/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, <<"parentName"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_call.gleam", 110).
?DOC(" Return an error from the function.\n").
-spec return_error(
    dagger@dsl@types:function_call(),
    dagger@dsl@types:error(),
    dagger@types:client(),
    fun(({ok, nil} | {error, dagger@types:query_error()}) -> XXQ)
) -> XXQ.
return_error(Parent, Error, Client, Handler) ->
    Field = {field,
        <<"returnError"/utf8>>,
        [{<<"error"/utf8>>, {g_deferred, erlang:element(2, Error)}}],
        []},
    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, <<"returnError"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_call.gleam", 131).
?DOC(" Set the return value of the function call to the provided value.\n").
-spec return_value(
    dagger@dsl@types:function_call(),
    binary(),
    dagger@types:client(),
    fun(({ok, nil} | {error, dagger@types:query_error()}) -> XXS)
) -> XXS.
return_value(Parent, Value, Client, Handler) ->
    Field = {field,
        <<"returnValue"/utf8>>,
        [{<<"value"/utf8>>, {g_string, Value}}],
        []},
    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, <<"returnValue"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

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

-file("src/dagger/dsl/function_call.gleam", 157).
?DOC(" A unique identifier for this FunctionCallArgValue.\n").
-spec function_call_arg_value_id(dagger@dsl@types:function_call_arg_value()) -> dagger@dsl@types:function_call_arg_value().
function_call_arg_value_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,
    {function_call_arg_value, New_op}.

-file("src/dagger/dsl/function_call.gleam", 167).
?DOC(" The name of the argument.\n").
-spec function_call_arg_value_name(
    dagger@dsl@types:function_call_arg_value(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XXU)
) -> XXU.
function_call_arg_value_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/function_call.gleam", 188).
?DOC(" The value of the argument represented as a JSON serialized string.\n").
-spec value(
    dagger@dsl@types:function_call_arg_value(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XXW)
) -> XXW.
value(Parent, Client, Handler) ->
    Field = {field, <<"value"/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, <<"value"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).