-module(dagger@dsl@function_arg).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/function_arg.gleam").
-export([function_arg/1, default_address/3, default_path/3, default_value/3, deprecated/3, description/3, id/1, ignore/3, name/3, source_map/1, type_def/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/function_arg.gleam", 9).
-spec function_arg(dagger@dsl@types:function_arg()) -> dagger@dsl@types:function_arg().
function_arg(Id) ->
    Field = {field,
        <<"loadFunctionArgFromID"/utf8>>,
        [{<<"id"/utf8>>, {g_deferred, erlang:element(2, Id)}}],
        []},
    {function_arg, {pure, [Field]}}.

-file("src/dagger/dsl/function_arg.gleam", 15).
?DOC(" Only applies to arguments of type Container. If the argument is not set, load it from the given address (e.g. alpine:latest)\n").
-spec default_address(
    dagger@dsl@types:function_arg(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XPB)
) -> XPB.
default_address(Parent, Client, Handler) ->
    Field = {field, <<"defaultAddress"/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,
                                            <<"defaultAddress"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_arg.gleam", 36).
?DOC(" Only applies to arguments of type File or Directory. If the argument is not set, load it from the given path in the context directory\n").
-spec default_path(
    dagger@dsl@types:function_arg(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XPD)
) -> XPD.
default_path(Parent, Client, Handler) ->
    Field = {field, <<"defaultPath"/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, <<"defaultPath"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_arg.gleam", 57).
?DOC(" A default value to use for this argument when not explicitly set by the caller, if any.\n").
-spec default_value(
    dagger@dsl@types:function_arg(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XPF)
) -> XPF.
default_value(Parent, Client, Handler) ->
    Field = {field, <<"defaultValue"/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,
                                            <<"defaultValue"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_arg.gleam", 78).
?DOC(" The reason this function is deprecated, if any.\n").
-spec deprecated(
    dagger@dsl@types:function_arg(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XPH)
) -> XPH.
deprecated(Parent, Client, Handler) ->
    Field = {field, <<"deprecated"/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, <<"deprecated"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_arg.gleam", 99).
?DOC(" A doc string for the argument, if any.\n").
-spec description(
    dagger@dsl@types:function_arg(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XPJ)
) -> XPJ.
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/function_arg.gleam", 120).
?DOC(" A unique identifier for this FunctionArg.\n").
-spec id(dagger@dsl@types:function_arg()) -> dagger@dsl@types:function_arg().
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_arg, New_op}.

-file("src/dagger/dsl/function_arg.gleam", 130).
?DOC(" Only applies to arguments of type Directory. The ignore patterns are applied to the input directory, and matching entries are filtered out, in a cache-efficient manner.\n").
-spec ignore(
    dagger@dsl@types:function_arg(),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> XPM)
) -> XPM.
ignore(Parent, Client, Handler) ->
    Field = {field, <<"ignore"/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, <<"ignore"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/function_arg.gleam", 151).
?DOC(" The name of the argument in lowerCamelCase format.\n").
-spec name(
    dagger@dsl@types:function_arg(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XPO)
) -> XPO.
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_arg.gleam", 172).
?DOC(" The location of this arg declaration.\n").
-spec source_map(dagger@dsl@types:function_arg()) -> dagger@dsl@types:source_map().
source_map(Parent) ->
    Field = {field, <<"sourceMap"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {source_map, New_op}.

-file("src/dagger/dsl/function_arg.gleam", 182).
?DOC(" The type of the argument.\n").
-spec type_def(dagger@dsl@types:function_arg()) -> dagger@dsl@types:type_def().
type_def(Parent) ->
    Field = {field, <<"typeDef"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {type_def, New_op}.