-module(dagger@dsl@generated_code).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/generated_code.gleam").
-export([generated_code/1, code/1, id/1, vcs_generated_paths/3, vcs_ignored_paths/3, with_v_c_s_generated_paths/2, with_v_c_s_ignored_paths/2]).

-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/generated_code.gleam", 9).
-spec generated_code(dagger@dsl@types:directory()) -> dagger@dsl@types:generated_code().
generated_code(Code) ->
    Field = {field,
        <<"generatedCode"/utf8>>,
        [{<<"code"/utf8>>, {g_deferred, erlang:element(2, Code)}}],
        []},
    {generated_code, {pure, [Field]}}.

-file("src/dagger/dsl/generated_code.gleam", 15).
?DOC(" The directory containing the generated code.\n").
-spec code(dagger@dsl@types:generated_code()) -> dagger@dsl@types:directory().
code(Parent) ->
    Field = {field, <<"code"/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/generated_code.gleam", 25).
?DOC(" A unique identifier for this GeneratedCode.\n").
-spec id(dagger@dsl@types:generated_code()) -> dagger@dsl@types:generated_code().
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,
    {generated_code, New_op}.

-file("src/dagger/dsl/generated_code.gleam", 35).
?DOC(" List of paths to mark generated in version control (i.e. .gitattributes).\n").
-spec vcs_generated_paths(
    dagger@dsl@types:generated_code(),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> RWU)
) -> RWU.
vcs_generated_paths(Parent, Client, Handler) ->
    Field = {field, <<"vcsGeneratedPaths"/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,
                                            <<"vcsGeneratedPaths"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/generated_code.gleam", 56).
?DOC(" List of paths to ignore in version control (i.e. .gitignore).\n").
-spec vcs_ignored_paths(
    dagger@dsl@types:generated_code(),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> RWX)
) -> RWX.
vcs_ignored_paths(Parent, Client, Handler) ->
    Field = {field, <<"vcsIgnoredPaths"/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,
                                            <<"vcsIgnoredPaths"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/generated_code.gleam", 77).
?DOC(" Set the list of paths to mark generated in version control.\n").
-spec with_v_c_s_generated_paths(
    dagger@dsl@types:generated_code(),
    list(binary())
) -> dagger@dsl@types:generated_code().
with_v_c_s_generated_paths(Parent, Paths) ->
    Field = {field,
        <<"withVCSGeneratedPaths"/utf8>>,
        [{<<"paths"/utf8>>,
                {g_list, gleam@list:map(Paths, fun(X) -> {g_string, X} end)}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {generated_code, New_op}.

-file("src/dagger/dsl/generated_code.gleam", 87).
?DOC(" Set the list of paths to ignore in version control.\n").
-spec with_v_c_s_ignored_paths(
    dagger@dsl@types:generated_code(),
    list(binary())
) -> dagger@dsl@types:generated_code().
with_v_c_s_ignored_paths(Parent, Paths) ->
    Field = {field,
        <<"withVCSIgnoredPaths"/utf8>>,
        [{<<"paths"/utf8>>,
                {g_list, gleam@list:map(Paths, fun(X) -> {g_string, X} end)}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {generated_code, New_op}.