-module(dagger@dsl@engine).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/engine.gleam").
-export([none/1, key/2, use_default_policy/2, engine/0, clients/3, engine_id/1, local_cache/1, name/3, engine_cache/1, entry_set/2, cache_id/1, max_used_space/3, min_free_space/3, prune/4, reserved_space/3, target_space/3, engine_cache_entry_set/1, disk_space_bytes/3, entries/4, entry_count/3, cache_entry_set_id/1]).
-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(boolean())}.

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

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

-file("src/dagger/dsl/engine.gleam", 28).
-spec key(opts(), binary()) -> opts().
key(Opts, Val) ->
    {opts, {some, Val}, erlang:element(3, Opts)}.

-file("src/dagger/dsl/engine.gleam", 32).
-spec use_default_policy(opts(), boolean()) -> opts().
use_default_policy(Opts, Val) ->
    {opts, erlang:element(2, Opts), {some, Val}}.

-file("src/dagger/dsl/engine.gleam", 36).
-spec engine() -> dagger@dsl@types:engine().
engine() ->
    Field = {field, <<"engine"/utf8>>, [], []},
    {engine, {pure, [Field]}}.

-file("src/dagger/dsl/engine.gleam", 42).
?DOC(" The list of connected client IDs\n").
-spec clients(
    dagger@dsl@types:engine(),
    dagger@types:client(),
    fun(({ok, list(binary())} | {error, dagger@types:query_error()}) -> NJR)
) -> NJR.
clients(Parent, Client, Handler) ->
    Field = {field, <<"clients"/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, <<"clients"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/engine.gleam", 63).
?DOC(" A unique identifier for this Engine.\n").
-spec engine_id(dagger@dsl@types:engine()) -> dagger@dsl@types:engine().
engine_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,
    {engine, New_op}.

-file("src/dagger/dsl/engine.gleam", 73).
?DOC(" The local (on-disk) cache for the Dagger engine\n").
-spec local_cache(dagger@dsl@types:engine()) -> dagger@dsl@types:engine_cache().
local_cache(Parent) ->
    Field = {field, <<"localCache"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {engine_cache, New_op}.

-file("src/dagger/dsl/engine.gleam", 83).
?DOC(" The name of the engine instance.\n").
-spec name(
    dagger@dsl@types:engine(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> NJT)
) -> NJT.
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/engine.gleam", 103).
-spec engine_cache(dagger@dsl@types:engine_cache()) -> dagger@dsl@types:engine_cache().
engine_cache(Id) ->
    Field = {field,
        <<"loadEngineCacheFromID"/utf8>>,
        [{<<"id"/utf8>>, {g_deferred, erlang:element(2, Id)}}],
        []},
    {engine_cache, {pure, [Field]}}.

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

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

-file("src/dagger/dsl/engine.gleam", 118).
?DOC(" The current set of entries in the cache\n").
-spec entry_set(dagger@dsl@types:engine_cache(), fun((opts()) -> opts())) -> dagger@dsl@types:engine_cache_entry_set().
entry_set(Parent, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"entrySet"/utf8>>, encode_entry_set(Opts), []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {engine_cache_entry_set, New_op}.

-file("src/dagger/dsl/engine.gleam", 129).
?DOC(" A unique identifier for this EngineCache.\n").
-spec cache_id(dagger@dsl@types:engine_cache()) -> dagger@dsl@types:engine_cache().
cache_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,
    {engine_cache, New_op}.

-file("src/dagger/dsl/engine.gleam", 139).
?DOC(" The maximum bytes to keep in the cache without pruning.\n").
-spec max_used_space(
    dagger@dsl@types:engine_cache(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> NJW)
) -> NJW.
max_used_space(Parent, Client, Handler) ->
    Field = {field, <<"maxUsedSpace"/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_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/engine.gleam", 160).
?DOC(" The target amount of free disk space the garbage collector will attempt to leave.\n").
-spec min_free_space(
    dagger@dsl@types:engine_cache(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> NJY)
) -> NJY.
min_free_space(Parent, Client, Handler) ->
    Field = {field, <<"minFreeSpace"/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_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/engine.gleam", 180).
-spec encode_prune(opts()) -> list({binary(), dagger@types:value()}).
encode_prune(Opts) ->
    gleam@list:filter_map([case erlang:element(3, Opts) of
                {some, Val} ->
                    {ok, {<<"useDefaultPolicy"/utf8>>, {g_bool, Val}}};

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

-file("src/dagger/dsl/engine.gleam", 190).
?DOC(" Prune the cache of releaseable entries\n").
-spec prune(
    dagger@dsl@types:engine_cache(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, nil} | {error, dagger@types:query_error()}) -> NKB)
) -> NKB.
prune(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"prune"/utf8>>, encode_prune(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, <<"prune"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/engine.gleam", 212).
?DOC(" The minimum amount of disk space this policy is guaranteed to retain.\n").
-spec reserved_space(
    dagger@dsl@types:engine_cache(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> NKD)
) -> NKD.
reserved_space(Parent, Client, Handler) ->
    Field = {field, <<"reservedSpace"/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_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/engine.gleam", 233).
?DOC(" The target number of bytes to keep when pruning.\n").
-spec target_space(
    dagger@dsl@types:engine_cache(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> NKF)
) -> NKF.
target_space(Parent, Client, Handler) ->
    Field = {field, <<"targetSpace"/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_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

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

-file("src/dagger/dsl/engine.gleam", 259).
?DOC(" The total disk space used by the cache entries in this set.\n").
-spec disk_space_bytes(
    dagger@dsl@types:engine_cache_entry_set(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> NKH)
) -> NKH.
disk_space_bytes(Parent, Client, Handler) ->
    Field = {field, <<"diskSpaceBytes"/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_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/engine.gleam", 280).
?DOC(" The list of individual cache entries in the set\n").
-spec entries(
    dagger@dsl@types:engine_cache_entry_set(),
    fun((dagger@dsl@types:engine_cache_entry()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:engine_cache_entry())} |
        {error, dagger@types:query_error()}) -> NKL)
) -> NKL.
entries(Parent, Select, Client, Handler) ->
    Subfields = Select({engine_cache_entry, {pure, []}}),
    Field = {field, <<"entries"/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(_) ->
                                                {engine_cache_entry,
                                                    {pure, Full_query}}
                                            end
                                        )}};

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

-file("src/dagger/dsl/engine.gleam", 302).
?DOC(" The number of cache entries in this set.\n").
-spec entry_count(
    dagger@dsl@types:engine_cache_entry_set(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> NKN)
) -> NKN.
entry_count(Parent, Client, Handler) ->
    Field = {field, <<"entryCount"/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_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/engine.gleam", 323).
?DOC(" A unique identifier for this EngineCacheEntrySet.\n").
-spec cache_entry_set_id(dagger@dsl@types:engine_cache_entry_set()) -> dagger@dsl@types:engine_cache_entry_set().
cache_entry_set_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,
    {engine_cache_entry_set, New_op}.