dagger_gleam

-module(dagger@dsl@engine_cache_entry).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/engine_cache_entry.gleam").
-export([engine_cache_entry/1, actively_used/3, created_time_unix_nano/3, description/3, disk_space_bytes/3, id/1, most_recent_use_time_unix_nano/3, record_type/3]).

-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/engine_cache_entry.gleam", 9).
-spec engine_cache_entry(dagger@dsl@types:engine_cache_entry()) -> dagger@dsl@types:engine_cache_entry().
engine_cache_entry(Id) ->
    Field = {field,
        <<"loadEngineCacheEntryFromID"/utf8>>,
        [{<<"id"/utf8>>, {g_deferred, erlang:element(2, Id)}}],
        []},
    {engine_cache_entry, {pure, [Field]}}.

-file("src/dagger/dsl/engine_cache_entry.gleam", 15).
?DOC(" Whether the cache entry is actively being used.\n").
-spec actively_used(
    dagger@dsl@types:engine_cache_entry(),
    dagger@types:client(),
    fun(({ok, boolean()} | {error, dagger@types:query_error()}) -> TIX)
) -> TIX.
actively_used(Parent, Client, Handler) ->
    Field = {field, <<"activelyUsed"/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_bool/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

-file("src/dagger/dsl/engine_cache_entry.gleam", 36).
?DOC(" The time the cache entry was created, in Unix nanoseconds.\n").
-spec created_time_unix_nano(
    dagger@dsl@types:engine_cache_entry(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> TIZ)
) -> TIZ.
created_time_unix_nano(Parent, Client, Handler) ->
    Field = {field, <<"createdTimeUnixNano"/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,
                                            <<"createdTimeUnixNano"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/engine_cache_entry.gleam", 57).
?DOC(" The description of the cache entry.\n").
-spec description(
    dagger@dsl@types:engine_cache_entry(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> TJB)
) -> TJB.
description(Parent, Client, Handler) ->
    Field = {field, <<"description"/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, <<"description"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/engine_cache_entry.gleam", 78).
?DOC(" The disk space used by the cache entry.\n").
-spec disk_space_bytes(
    dagger@dsl@types:engine_cache_entry(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> TJD)
) -> TJD.
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_cache_entry.gleam", 99).
?DOC(" A unique identifier for this EngineCacheEntry.\n").
-spec id(dagger@dsl@types:engine_cache_entry()) -> dagger@dsl@types:engine_cache_entry().
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, New_op}.

-file("src/dagger/dsl/engine_cache_entry.gleam", 109).
?DOC(" The most recent time the cache entry was used, in Unix nanoseconds.\n").
-spec most_recent_use_time_unix_nano(
    dagger@dsl@types:engine_cache_entry(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> TJF)
) -> TJF.
most_recent_use_time_unix_nano(Parent, Client, Handler) ->
    Field = {field, <<"mostRecentUseTimeUnixNano"/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,
                                            <<"mostRecentUseTimeUnixNano"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/engine_cache_entry.gleam", 130).
?DOC(" The type of the cache record (e.g. regular, internal, frontend, source.local, source.git.checkout, exec.cachemount).\n").
-spec record_type(
    dagger@dsl@types:engine_cache_entry(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> TJH)
) -> TJH.
record_type(Parent, Client, Handler) ->
    Field = {field, <<"recordType"/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, <<"recordType"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).