-module(dagger@dsl@git).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/git.gleam").
-export([none/1, opt_ssh_known_hosts/2, opt_ssh_auth_socket/2, opt_http_auth_username/2, opt_http_auth_token/2, opt_http_auth_header/2, opt_experimental_service_host/2, opt_patterns/2, opt_discard_git_dir/2, opt_depth/2, git_repository/2, branch/2, branches/4, repository_commit/2, head/1, repository_id/1, latest_version/1, repository_ref/2, tag/2, tags/4, uncommitted/1, url/3, git_ref/1, ref_commit/3, common_ancestor/2, ref_id/1, ref_ref/3, tree/2]).
-export_type([for_git_repository/0, for_tree/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_git_repository() :: any().

-type for_tree() :: any().

-opaque opts(YVS) :: {opts,
        gleam@option:option(binary()),
        gleam@option:option(dagger@dsl@types:socket()),
        gleam@option:option(binary()),
        gleam@option:option(dagger@dsl@types:secret()),
        gleam@option:option(dagger@dsl@types:secret()),
        gleam@option:option(dagger@dsl@types:service()),
        gleam@option:option(list(binary())),
        gleam@option:option(boolean()),
        gleam@option:option(integer())} |
    {gleam_phantom, YVS}.

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

-file("src/dagger/dsl/git.gleam", 41).
-spec none(opts(YVV)) -> opts(YVV).
none(Opts) ->
    Opts.

-file("src/dagger/dsl/git.gleam", 45).
-spec opt_ssh_known_hosts(opts(for_git_repository()), binary()) -> opts(for_git_repository()).
opt_ssh_known_hosts(Opts, Val) ->
    {opts,
        {some, Val},
        erlang:element(3, Opts),
        erlang:element(4, Opts),
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        erlang:element(7, Opts),
        erlang:element(8, Opts),
        erlang:element(9, Opts),
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 49).
-spec opt_ssh_auth_socket(opts(for_git_repository()), dagger@dsl@types:socket()) -> opts(for_git_repository()).
opt_ssh_auth_socket(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        {some, Val},
        erlang:element(4, Opts),
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        erlang:element(7, Opts),
        erlang:element(8, Opts),
        erlang:element(9, Opts),
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 53).
-spec opt_http_auth_username(opts(for_git_repository()), binary()) -> opts(for_git_repository()).
opt_http_auth_username(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        {some, Val},
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        erlang:element(7, Opts),
        erlang:element(8, Opts),
        erlang:element(9, Opts),
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 57).
-spec opt_http_auth_token(opts(for_git_repository()), dagger@dsl@types:secret()) -> opts(for_git_repository()).
opt_http_auth_token(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        erlang:element(4, Opts),
        {some, Val},
        erlang:element(6, Opts),
        erlang:element(7, Opts),
        erlang:element(8, Opts),
        erlang:element(9, Opts),
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 61).
-spec opt_http_auth_header(
    opts(for_git_repository()),
    dagger@dsl@types:secret()
) -> opts(for_git_repository()).
opt_http_auth_header(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        erlang:element(4, Opts),
        erlang:element(5, Opts),
        {some, Val},
        erlang:element(7, Opts),
        erlang:element(8, Opts),
        erlang:element(9, Opts),
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 65).
-spec opt_experimental_service_host(
    opts(for_git_repository()),
    dagger@dsl@types:service()
) -> opts(for_git_repository()).
opt_experimental_service_host(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        erlang:element(4, Opts),
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        {some, Val},
        erlang:element(8, Opts),
        erlang:element(9, Opts),
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 69).
-spec opt_patterns(opts(YWK), list(binary())) -> opts(YWK).
opt_patterns(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        erlang:element(4, Opts),
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        erlang:element(7, Opts),
        {some, Val},
        erlang:element(9, Opts),
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 73).
-spec opt_discard_git_dir(opts(for_tree()), boolean()) -> opts(for_tree()).
opt_discard_git_dir(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        erlang:element(4, Opts),
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        erlang:element(7, Opts),
        erlang:element(8, Opts),
        {some, Val},
        erlang:element(10, Opts)}.

-file("src/dagger/dsl/git.gleam", 77).
-spec opt_depth(opts(for_tree()), integer()) -> opts(for_tree()).
opt_depth(Opts, Val) ->
    {opts,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        erlang:element(4, Opts),
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        erlang:element(7, Opts),
        erlang:element(8, Opts),
        erlang:element(9, Opts),
        {some, Val}}.

-file("src/dagger/dsl/git.gleam", 81).
-spec encode_git_repository(opts(any())) -> list({binary(),
    dagger@types:value()}).
encode_git_repository(Opts) ->
    gleam@list:filter_map([case erlang:element(2, Opts) of
                {some, Val} ->
                    {ok, {<<"sshKnownHosts"/utf8>>, {g_string, Val}}};

                none ->
                    {error, nil}
            end, case erlang:element(3, Opts) of
                {some, Val@1} ->
                    {ok,
                        {<<"sshAuthSocket"/utf8>>,
                            {g_deferred, erlang:element(2, Val@1)}}};

                none ->
                    {error, nil}
            end, case erlang:element(4, Opts) of
                {some, Val@2} ->
                    {ok, {<<"httpAuthUsername"/utf8>>, {g_string, Val@2}}};

                none ->
                    {error, nil}
            end, case erlang:element(5, Opts) of
                {some, Val@3} ->
                    {ok,
                        {<<"httpAuthToken"/utf8>>,
                            {g_deferred, erlang:element(2, Val@3)}}};

                none ->
                    {error, nil}
            end, case erlang:element(6, Opts) of
                {some, Val@4} ->
                    {ok,
                        {<<"httpAuthHeader"/utf8>>,
                            {g_deferred, erlang:element(2, Val@4)}}};

                none ->
                    {error, nil}
            end, case erlang:element(7, Opts) of
                {some, Val@5} ->
                    {ok,
                        {<<"experimentalServiceHost"/utf8>>,
                            {g_deferred, erlang:element(2, Val@5)}}};

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

-file("src/dagger/dsl/git.gleam", 110).
-spec git_repository(
    binary(),
    fun((opts(for_git_repository())) -> opts(for_git_repository()))
) -> dagger@dsl@types:git_repository().
git_repository(Url, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field,
        <<"git"/utf8>>,
        lists:append(
            [{<<"url"/utf8>>, {g_string, Url}}],
            encode_git_repository(Opts)
        ),
        []},
    {git_repository, {pure, [Field]}}.

-file("src/dagger/dsl/git.gleam", 117).
?DOC(" Returns details of a branch.\n").
-spec branch(dagger@dsl@types:git_repository(), binary()) -> dagger@dsl@types:git_ref().
branch(Parent, Name) ->
    Field = {field,
        <<"branch"/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,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 126).
-spec encode_branches(opts(any())) -> list({binary(), dagger@types:value()}).
encode_branches(Opts) ->
    gleam@list:filter_map([case erlang:element(8, Opts) of
                {some, Val} ->
                    {ok,
                        {<<"patterns"/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/git.gleam", 136).
?DOC(" branches that match any of the given glob patterns.\n").
-spec branches(
    dagger@dsl@types:git_repository(),
    fun((opts(YXA)) -> opts(YXA)),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> YXA)
) -> YXA.
branches(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"branches"/utf8>>, encode_branches(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,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                )
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/git.gleam", 158).
?DOC(" Returns details of a commit.\n").
-spec repository_commit(dagger@dsl@types:git_repository(), binary()) -> dagger@dsl@types:git_ref().
repository_commit(Parent, Id) ->
    Field = {field, <<"commit"/utf8>>, [{<<"id"/utf8>>, {g_string, Id}}], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 168).
?DOC(" Returns details for HEAD.\n").
-spec head(dagger@dsl@types:git_repository()) -> dagger@dsl@types:git_ref().
head(Parent) ->
    Field = {field, <<"head"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 178).
?DOC(" A unique identifier for this GitRepository.\n").
-spec repository_id(dagger@dsl@types:git_repository()) -> dagger@dsl@types:git_repository().
repository_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,
    {git_repository, New_op}.

-file("src/dagger/dsl/git.gleam", 188).
?DOC(" Returns details for the latest semver tag.\n").
-spec latest_version(dagger@dsl@types:git_repository()) -> dagger@dsl@types:git_ref().
latest_version(Parent) ->
    Field = {field, <<"latestVersion"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 198).
?DOC(" Returns details of a ref.\n").
-spec repository_ref(dagger@dsl@types:git_repository(), binary()) -> dagger@dsl@types:git_ref().
repository_ref(Parent, Name) ->
    Field = {field, <<"ref"/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,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 208).
?DOC(" Returns details of a tag.\n").
-spec tag(dagger@dsl@types:git_repository(), binary()) -> dagger@dsl@types:git_ref().
tag(Parent, Name) ->
    Field = {field, <<"tag"/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,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 217).
-spec encode_tags(opts(any())) -> list({binary(), dagger@types:value()}).
encode_tags(Opts) ->
    gleam@list:filter_map([case erlang:element(8, Opts) of
                {some, Val} ->
                    {ok,
                        {<<"patterns"/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/git.gleam", 227).
?DOC(" tags that match any of the given glob patterns.\n").
-spec tags(
    dagger@dsl@types:git_repository(),
    fun((opts(YXI)) -> opts(YXI)),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> YXI)
) -> YXI.
tags(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"tags"/utf8>>, encode_tags(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,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                )
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/git.gleam", 249).
?DOC(" Returns the changeset of uncommitted changes in the git repository.\n").
-spec uncommitted(dagger@dsl@types:git_repository()) -> dagger@dsl@types:changeset().
uncommitted(Parent) ->
    Field = {field, <<"uncommitted"/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/git.gleam", 259).
?DOC(" The URL of the git repository.\n").
-spec url(
    dagger@dsl@types:git_repository(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> YXO)
) -> YXO.
url(Parent, Client, Handler) ->
    Field = {field, <<"url"/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, <<"url"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

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

-file("src/dagger/dsl/git.gleam", 285).
?DOC(" The resolved commit id at this ref.\n").
-spec ref_commit(
    dagger@dsl@types:git_ref(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> YXQ)
) -> YXQ.
ref_commit(Parent, Client, Handler) ->
    Field = {field, <<"commit"/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, <<"commit"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/git.gleam", 306).
?DOC(" Find the best common ancestor between this ref and another ref.\n").
-spec common_ancestor(dagger@dsl@types:git_ref(), dagger@dsl@types:git_ref()) -> dagger@dsl@types:git_ref().
common_ancestor(Parent, Other) ->
    Field = {field,
        <<"commonAncestor"/utf8>>,
        [{<<"other"/utf8>>, {g_deferred, erlang:element(2, Other)}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 316).
?DOC(" A unique identifier for this GitRef.\n").
-spec ref_id(dagger@dsl@types:git_ref()) -> dagger@dsl@types:git_ref().
ref_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,
    {git_ref, New_op}.

-file("src/dagger/dsl/git.gleam", 326).
?DOC(" The resolved ref name at this ref.\n").
-spec ref_ref(
    dagger@dsl@types:git_ref(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> YXS)
) -> YXS.
ref_ref(Parent, Client, Handler) ->
    Field = {field, <<"ref"/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, <<"ref"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/git.gleam", 346).
-spec encode_tree(opts(any())) -> list({binary(), dagger@types:value()}).
encode_tree(Opts) ->
    gleam@list:filter_map([case erlang:element(9, Opts) of
                {some, Val} ->
                    {ok, {<<"discardGitDir"/utf8>>, {g_bool, Val}}};

                none ->
                    {error, nil}
            end, case erlang:element(10, Opts) of
                {some, Val@1} ->
                    {ok, {<<"depth"/utf8>>, {g_int, Val@1}}};

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

-file("src/dagger/dsl/git.gleam", 360).
?DOC(" The filesystem tree at this ref.\n").
-spec tree(
    dagger@dsl@types:git_ref(),
    fun((opts(for_tree())) -> opts(for_tree()))
) -> dagger@dsl@types:directory().
tree(Parent, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"tree"/utf8>>, encode_tree(Opts), []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {directory, New_op}.