-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, ssh_known_hosts/2, ssh_auth_socket/2, http_auth_username/2, http_auth_token/2, http_auth_header/2, experimental_service_host/2, patterns/2, discard_git_dir/2, 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([opts/0]).

-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 opts() :: {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())}.

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

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

-file("src/dagger/dsl/git.gleam", 42).
-spec ssh_known_hosts(opts(), binary()) -> opts().
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", 46).
-spec ssh_auth_socket(opts(), dagger@dsl@types:socket()) -> opts().
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", 50).
-spec http_auth_username(opts(), binary()) -> opts().
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", 54).
-spec http_auth_token(opts(), dagger@dsl@types:secret()) -> opts().
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", 58).
-spec http_auth_header(opts(), dagger@dsl@types:secret()) -> opts().
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", 62).
-spec experimental_service_host(opts(), dagger@dsl@types:service()) -> opts().
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", 66).
-spec patterns(opts(), list(binary())) -> opts().
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", 70).
-spec discard_git_dir(opts(), boolean()) -> opts().
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", 74).
-spec depth(opts(), integer()) -> opts().
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", 78).
-spec encode_git_repository(opts()) -> 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", 107).
-spec git_repository(binary(), fun((opts()) -> opts())) -> 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", 114).
?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", 123).
-spec encode_branches(opts()) -> 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", 133).
?DOC(" branches that match any of the given glob patterns.\n").
-spec branches(
    dagger@dsl@types:git_repository(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> SKC)
) -> SKC.
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", 155).
?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", 165).
?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", 175).
?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", 185).
?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", 195).
?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", 205).
?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", 214).
-spec encode_tags(opts()) -> 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", 224).
?DOC(" tags that match any of the given glob patterns.\n").
-spec tags(
    dagger@dsl@types:git_repository(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> SKG)
) -> SKG.
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", 246).
?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", 256).
?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()}) -> SKI)
) -> SKI.
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", 276).
-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", 282).
?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()}) -> SKK)
) -> SKK.
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", 303).
?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", 313).
?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", 323).
?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()}) -> SKM)
) -> SKM.
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", 343).
-spec encode_tree(opts()) -> 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", 357).
?DOC(" The filesystem tree at this ref.\n").
-spec tree(dagger@dsl@types:git_ref(), fun((opts()) -> opts())) -> 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}.