dagger_gleam

-module(dagger@dsl@service).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/service.gleam").
-export([none/1, port/2, scheme/2, kill/2, cmd/2, opt_ports/2, random/2, service/1, endpoint/4, hostname/3, id/1, ports/4, start/1, stop/2, sync/1, terminal/2, up/4, with_hostname/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(integer()),
        gleam@option:option(binary()),
        gleam@option:option(boolean()),
        gleam@option:option(list(binary())),
        gleam@option:option(list(dagger@dsl@types:port_forward())),
        gleam@option:option(boolean())}.

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

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

-file("src/dagger/dsl/service.gleam", 36).
-spec port(opts(), integer()) -> opts().
port(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)}.

-file("src/dagger/dsl/service.gleam", 40).
-spec scheme(opts(), binary()) -> opts().
scheme(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)}.

-file("src/dagger/dsl/service.gleam", 44).
-spec kill(opts(), boolean()) -> opts().
kill(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)}.

-file("src/dagger/dsl/service.gleam", 48).
-spec cmd(opts(), list(binary())) -> opts().
cmd(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)}.

-file("src/dagger/dsl/service.gleam", 52).
-spec opt_ports(opts(), list(dagger@dsl@types:port_forward())) -> opts().
opt_ports(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)}.

-file("src/dagger/dsl/service.gleam", 56).
-spec random(opts(), boolean()) -> opts().
random(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}}.

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

-file("src/dagger/dsl/service.gleam", 65).
-spec encode_endpoint(opts()) -> list({binary(), dagger@types:value()}).
encode_endpoint(Opts) ->
    gleam@list:filter_map([case erlang:element(2, Opts) of
                {some, Val} ->
                    {ok, {<<"port"/utf8>>, {g_int, Val}}};

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

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

-file("src/dagger/dsl/service.gleam", 81).
?DOC(
    " Retrieves an endpoint that clients can use to reach this container.\n"
    " If no port is specified, the first exposed port is used. If none exist an error is returned.\n"
    " If a scheme is specified, a URL is returned. Otherwise, a host:port pair is returned.\n"
).
-spec endpoint(
    dagger@dsl@types:service(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XXX)
) -> XXX.
endpoint(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"endpoint"/utf8>>, encode_endpoint(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,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/service.gleam", 103).
?DOC(" Retrieves a hostname which can be used by clients to reach this container.\n").
-spec hostname(
    dagger@dsl@types:service(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XXZ)
) -> XXZ.
hostname(Parent, Client, Handler) ->
    Field = {field, <<"hostname"/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, <<"hostname"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/service.gleam", 124).
?DOC(" A unique identifier for this Service.\n").
-spec id(dagger@dsl@types:service()) -> dagger@dsl@types:service().
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,
    {service, New_op}.

-file("src/dagger/dsl/service.gleam", 134).
?DOC(" Retrieves the list of ports provided by the service.\n").
-spec ports(
    dagger@dsl@types:service(),
    fun((dagger@dsl@types:port_()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:port_())} |
        {error, dagger@types:query_error()}) -> XYD)
) -> XYD.
ports(Parent, Select, Client, Handler) ->
    Subfields = Select({port, {pure, []}}),
    Field = {field, <<"ports"/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(_) ->
                                                {port, {pure, Full_query}}
                                            end
                                        )}};

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

-file("src/dagger/dsl/service.gleam", 157).
?DOC(
    " Start the service and wait for its health checks to succeed.\n"
    " Services bound to a Container do not need to be manually started.\n"
).
-spec start(dagger@dsl@types:service()) -> dagger@dsl@types:service().
start(Parent) ->
    Field = {field, <<"start"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {service, New_op}.

-file("src/dagger/dsl/service.gleam", 166).
-spec encode_stop(opts()) -> list({binary(), dagger@types:value()}).
encode_stop(Opts) ->
    gleam@list:filter_map([case erlang:element(4, Opts) of
                {some, Val} ->
                    {ok, {<<"kill"/utf8>>, {g_bool, Val}}};

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

-file("src/dagger/dsl/service.gleam", 176).
?DOC(" Stop the service.\n").
-spec stop(dagger@dsl@types:service(), fun((opts()) -> opts())) -> dagger@dsl@types:service().
stop(Parent, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"stop"/utf8>>, encode_stop(Opts), []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {service, New_op}.

-file("src/dagger/dsl/service.gleam", 187).
?DOC(" Forces evaluation of the pipeline in the engine.\n").
-spec sync(dagger@dsl@types:service()) -> dagger@dsl@types:service().
sync(Parent) ->
    Field = {field, <<"sync"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {service, New_op}.

-file("src/dagger/dsl/service.gleam", 196).
-spec encode_terminal(opts()) -> list({binary(), dagger@types:value()}).
encode_terminal(Opts) ->
    gleam@list:filter_map([case erlang:element(5, Opts) of
                {some, Val} ->
                    {ok,
                        {<<"cmd"/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/service.gleam", 206).
-spec terminal(dagger@dsl@types:service(), fun((opts()) -> opts())) -> dagger@dsl@types:service().
terminal(Parent, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"terminal"/utf8>>, encode_terminal(Opts), []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {service, New_op}.

-file("src/dagger/dsl/service.gleam", 216).
-spec encode_up(opts()) -> list({binary(), dagger@types:value()}).
encode_up(Opts) ->
    gleam@list:filter_map([case erlang:element(6, Opts) of
                {some, Val} ->
                    {ok,
                        {<<"ports"/utf8>>,
                            {g_list,
                                gleam@list:map(
                                    Val,
                                    fun(X) ->
                                        {g_object,
                                            dagger@dsl@types:port_forward_to_json(
                                                X
                                            )}
                                    end
                                )}}};

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

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

-file("src/dagger/dsl/service.gleam", 230).
?DOC(" Creates a tunnel that forwards traffic from the caller's network to this service.\n").
-spec up(
    dagger@dsl@types:service(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, nil} | {error, dagger@types:query_error()}) -> XYI)
) -> XYI.
up(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"up"/utf8>>, encode_up(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,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_dynamic/1}
                            )
                        ) of
                            {ok, _} ->
                                {pure, {ok, nil}};

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

-file("src/dagger/dsl/service.gleam", 252).
?DOC(" Configures a hostname which can be used by clients within the session to reach this container.\n").
-spec with_hostname(dagger@dsl@types:service(), binary()) -> dagger@dsl@types:service().
with_hostname(Parent, Hostname) ->
    Field = {field,
        <<"withHostname"/utf8>>,
        [{<<"hostname"/utf8>>, {g_string, Hostname}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {service, New_op}.