dagger_gleam

-module(dagger@dsl@file).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/file.gleam").
-export([none/1, permissions/2, offset_lines/2, limit_lines/2, exclude_metadata/2, allow_parent_dir_path/2, literal/2, multiline/2, dotall/2, insensitive/2, skip_ignored/2, skip_hidden/2, files_only/2, limit/2, paths/2, globs/2, all/2, first_from/2, file/3, as_env_file/1, as_j_s_o_n/1, chown/2, contents/4, digest/4, export/5, id/1, name/3, search/6, size/3, stat/1, sync/1, with_name/2, with_replaced/4, with_timestamps/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(integer()),
        gleam@option:option(integer()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(integer()),
        gleam@option:option(list(binary())),
        gleam@option:option(list(binary())),
        gleam@option:option(boolean()),
        gleam@option:option(integer())}.

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

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

-file("src/dagger/dsl/file.gleam", 58).
-spec permissions(opts(), integer()) -> opts().
permissions(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 62).
-spec offset_lines(opts(), integer()) -> opts().
offset_lines(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 66).
-spec limit_lines(opts(), integer()) -> opts().
limit_lines(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 70).
-spec exclude_metadata(opts(), boolean()) -> opts().
exclude_metadata(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 74).
-spec allow_parent_dir_path(opts(), boolean()) -> opts().
allow_parent_dir_path(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 78).
-spec literal(opts(), boolean()) -> opts().
literal(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 82).
-spec multiline(opts(), boolean()) -> opts().
multiline(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 86).
-spec dotall(opts(), boolean()) -> opts().
dotall(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),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 90).
-spec insensitive(opts(), boolean()) -> opts().
insensitive(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},
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 94).
-spec skip_ignored(opts(), boolean()) -> opts().
skip_ignored(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),
        erlang:element(10, Opts),
        {some, Val},
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 98).
-spec skip_hidden(opts(), boolean()) -> opts().
skip_hidden(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),
        erlang:element(10, Opts),
        erlang:element(11, Opts),
        {some, Val},
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 102).
-spec files_only(opts(), boolean()) -> opts().
files_only(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),
        erlang:element(10, Opts),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        {some, Val},
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 106).
-spec limit(opts(), integer()) -> opts().
limit(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),
        erlang:element(10, Opts),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        {some, Val},
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 110).
-spec paths(opts(), list(binary())) -> opts().
paths(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),
        erlang:element(10, Opts),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        {some, Val},
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 114).
-spec globs(opts(), list(binary())) -> opts().
globs(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),
        erlang:element(10, Opts),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        {some, Val},
        erlang:element(17, Opts),
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 118).
-spec all(opts(), boolean()) -> opts().
all(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),
        erlang:element(10, Opts),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        {some, Val},
        erlang:element(18, Opts)}.

-file("src/dagger/dsl/file.gleam", 122).
-spec first_from(opts(), integer()) -> opts().
first_from(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),
        erlang:element(10, Opts),
        erlang:element(11, Opts),
        erlang:element(12, Opts),
        erlang:element(13, Opts),
        erlang:element(14, Opts),
        erlang:element(15, Opts),
        erlang:element(16, Opts),
        erlang:element(17, Opts),
        {some, Val}}.

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

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

-file("src/dagger/dsl/file.gleam", 135).
-spec file(binary(), binary(), fun((opts()) -> opts())) -> dagger@dsl@types:file().
file(Name, Contents, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field,
        <<"file"/utf8>>,
        lists:append(
            [{<<"name"/utf8>>, {g_string, Name}},
                {<<"contents"/utf8>>, {g_string, Contents}}],
            encode_file(Opts)
        ),
        []},
    {file, {pure, [Field]}}.

-file("src/dagger/dsl/file.gleam", 142).
?DOC(" Parse as an env file\n").
-spec as_env_file(dagger@dsl@types:file()) -> dagger@dsl@types:env_file().
as_env_file(Parent) ->
    Field = {field, <<"asEnvFile"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {env_file, New_op}.

-file("src/dagger/dsl/file.gleam", 152).
?DOC(" Parse the file contents as JSON.\n").
-spec as_j_s_o_n(dagger@dsl@types:file()) -> dagger@dsl@types:j_s_o_n_value().
as_j_s_o_n(Parent) ->
    Field = {field, <<"asJSON"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {j_s_o_n_value, New_op}.

-file("src/dagger/dsl/file.gleam", 162).
?DOC(" Change the owner of the file recursively.\n").
-spec chown(dagger@dsl@types:file(), binary()) -> dagger@dsl@types:file().
chown(Parent, Owner) ->
    Field = {field,
        <<"chown"/utf8>>,
        [{<<"owner"/utf8>>, {g_string, Owner}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {file, New_op}.

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

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

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

-file("src/dagger/dsl/file.gleam", 185).
?DOC(" Retrieves the contents of the file.\n").
-spec contents(
    dagger@dsl@types:file(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> QBV)
) -> QBV.
contents(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"contents"/utf8>>, encode_contents(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, <<"contents"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

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

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

-file("src/dagger/dsl/file.gleam", 216).
?DOC(" Return the file's digest. The format of the digest is not guaranteed to be stable between releases of Dagger. It is guaranteed to be stable between invocations of the same Dagger engine.\n").
-spec digest(
    dagger@dsl@types:file(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> QBY)
) -> QBY.
digest(Parent, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"digest"/utf8>>, encode_digest(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, <<"digest"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

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

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

-file("src/dagger/dsl/file.gleam", 247).
?DOC(" Writes the file to a file path on the host.\n").
-spec export(
    dagger@dsl@types:file(),
    binary(),
    fun((opts()) -> opts()),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> QCB)
) -> QCB.
export(Parent, Path, With_fn, Client, Handler) ->
    Opts = With_fn(defaults()),
    Field = {field,
        <<"export"/utf8>>,
        lists:append([{<<"path"/utf8>>, {g_string, Path}}], encode_export(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@1 = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path@1,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

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

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

-file("src/dagger/dsl/file.gleam", 279).
?DOC(" Retrieves the name of the file.\n").
-spec name(
    dagger@dsl@types:file(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> QCD)
) -> QCD.
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/file.gleam", 299).
-spec encode_search(opts()) -> list({binary(), dagger@types:value()}).
encode_search(Opts) ->
    gleam@list:filter_map([case erlang:element(7, Opts) of
                {some, Val} ->
                    {ok, {<<"literal"/utf8>>, {g_bool, Val}}};

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

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

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

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

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

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

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

                none ->
                    {error, nil}
            end, case erlang:element(15, Opts) of
                {some, Val@8} ->
                    {ok,
                        {<<"paths"/utf8>>,
                            {g_list,
                                gleam@list:map(
                                    Val@8,
                                    fun(X) -> {g_string, X} end
                                )}}};

                none ->
                    {error, nil}
            end, case erlang:element(16, Opts) of
                {some, Val@9} ->
                    {ok,
                        {<<"globs"/utf8>>,
                            {g_list,
                                gleam@list:map(
                                    Val@9,
                                    fun(X@1) -> {g_string, X@1} end
                                )}}};

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

-file("src/dagger/dsl/file.gleam", 346).
?DOC(
    " Searches for content matching the given regular expression or literal string.\n"
    " Uses Rust regex syntax; escape literal ., [, ], {, }, | with backslashes.\n"
).
-spec search(
    dagger@dsl@types:file(),
    binary(),
    fun((opts()) -> opts()),
    fun((dagger@dsl@types:search_result()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:search_result())} |
        {error, dagger@types:query_error()}) -> QCI)
) -> QCI.
search(Parent, Pattern, With_fn, Select, Client, Handler) ->
    Opts = With_fn(defaults()),
    Subfields = Select({search_result, {pure, []}}),
    Field = {field,
        <<"search"/utf8>>,
        lists:append(
            [{<<"pattern"/utf8>>, {g_string, Pattern}}],
            encode_search(Opts)
        ),
        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(_) ->
                                                {search_result,
                                                    {pure, Full_query}}
                                            end
                                        )}};

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

-file("src/dagger/dsl/file.gleam", 369).
?DOC(" Retrieves the size of the file, in bytes.\n").
-spec size(
    dagger@dsl@types:file(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> QCK)
) -> QCK.
size(Parent, Client, Handler) ->
    Field = {field, <<"size"/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, <<"size"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/file.gleam", 390).
?DOC(" Return file status\n").
-spec stat(dagger@dsl@types:file()) -> dagger@dsl@types:stat().
stat(Parent) ->
    Field = {field, <<"stat"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {stat, New_op}.

-file("src/dagger/dsl/file.gleam", 400).
?DOC(" Force evaluation in the engine.\n").
-spec sync(dagger@dsl@types:file()) -> dagger@dsl@types:file().
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,
    {file, New_op}.

-file("src/dagger/dsl/file.gleam", 410).
?DOC(" Retrieves this file with its name set to the given name.\n").
-spec with_name(dagger@dsl@types:file(), binary()) -> dagger@dsl@types:file().
with_name(Parent, Name) ->
    Field = {field,
        <<"withName"/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,
    {file, New_op}.

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

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

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

-file("src/dagger/dsl/file.gleam", 437).
?DOC(
    " Retrieves the file with content replaced with the given text.\n"
    " If 'all' is true, all occurrences of the pattern will be replaced.\n"
    " If 'firstAfter' is specified, only the first match starting at the specified line will be replaced.\n"
    " If neither are specified, and there are multiple matches for the pattern, this will error.\n"
    " If there are no matches for the pattern, this will error.\n"
).
-spec with_replaced(
    dagger@dsl@types:file(),
    binary(),
    binary(),
    fun((opts()) -> opts())
) -> dagger@dsl@types:file().
with_replaced(Parent, Search, Replacement, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field,
        <<"withReplaced"/utf8>>,
        lists:append(
            [{<<"search"/utf8>>, {g_string, Search}},
                {<<"replacement"/utf8>>, {g_string, Replacement}}],
            encode_with_replaced(Opts)
        ),
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {file, New_op}.

-file("src/dagger/dsl/file.gleam", 448).
?DOC(" Retrieves this file with its created/modified timestamps set to the given time.\n").
-spec with_timestamps(dagger@dsl@types:file(), integer()) -> dagger@dsl@types:file().
with_timestamps(Parent, Timestamp) ->
    Field = {field,
        <<"withTimestamps"/utf8>>,
        [{<<"timestamp"/utf8>>, {g_int, Timestamp}}],
        []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {file, New_op}.