# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'ChmodArgsArgs',
    'MkdirArgsArgs',
    'MktempArgsArgs',
    'MvArgsArgs',
    'RmArgsArgs',
    'TarArgsArgs',
    'TeeArgsArgs',
    'WgetArgsArgs',
]

@pulumi.input_type
class ChmodArgsArgs:
    def __init__(__self__, *,
                 files: pulumi.Input[Sequence[pulumi.Input[str]]],
                 changes: Optional[pulumi.Input[bool]] = None,
                 help: Optional[pulumi.Input[bool]] = None,
                 mode: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 no_preserve_root: Optional[pulumi.Input[bool]] = None,
                 octal_mode: Optional[pulumi.Input[str]] = None,
                 preserve_root: Optional[pulumi.Input[bool]] = None,
                 quiet: Optional[pulumi.Input[bool]] = None,
                 recursive: Optional[pulumi.Input[bool]] = None,
                 reference: Optional[pulumi.Input[str]] = None,
                 verbose: Optional[pulumi.Input[bool]] = None,
                 version: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "files", files)
        if changes is not None:
            pulumi.set(__self__, "changes", changes)
        if help is not None:
            pulumi.set(__self__, "help", help)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if no_preserve_root is not None:
            pulumi.set(__self__, "no_preserve_root", no_preserve_root)
        if octal_mode is not None:
            pulumi.set(__self__, "octal_mode", octal_mode)
        if preserve_root is not None:
            pulumi.set(__self__, "preserve_root", preserve_root)
        if quiet is not None:
            pulumi.set(__self__, "quiet", quiet)
        if recursive is not None:
            pulumi.set(__self__, "recursive", recursive)
        if reference is not None:
            pulumi.set(__self__, "reference", reference)
        if verbose is not None:
            pulumi.set(__self__, "verbose", verbose)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def files(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "files")

    @files.setter
    def files(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "files", value)

    @property
    @pulumi.getter
    def changes(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "changes")

    @changes.setter
    def changes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "changes", value)

    @property
    @pulumi.getter
    def help(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "help")

    @help.setter
    def help(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "help", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="noPreserveRoot")
    def no_preserve_root(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_preserve_root")

    @no_preserve_root.setter
    def no_preserve_root(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_preserve_root", value)

    @property
    @pulumi.getter(name="octalMode")
    def octal_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "octal_mode")

    @octal_mode.setter
    def octal_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "octal_mode", value)

    @property
    @pulumi.getter(name="preserveRoot")
    def preserve_root(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "preserve_root")

    @preserve_root.setter
    def preserve_root(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preserve_root", value)

    @property
    @pulumi.getter
    def quiet(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "quiet")

    @quiet.setter
    def quiet(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "quiet", value)

    @property
    @pulumi.getter
    def recursive(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "recursive")

    @recursive.setter
    def recursive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "recursive", value)

    @property
    @pulumi.getter
    def reference(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "reference")

    @reference.setter
    def reference(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "reference", value)

    @property
    @pulumi.getter
    def verbose(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "verbose")

    @verbose.setter
    def verbose(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verbose", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class MkdirArgsArgs:
    def __init__(__self__, *,
                 directory: pulumi.Input[Sequence[pulumi.Input[str]]],
                 help: Optional[pulumi.Input[bool]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 parents: Optional[pulumi.Input[bool]] = None,
                 verbose: Optional[pulumi.Input[bool]] = None,
                 version: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "directory", directory)
        if help is not None:
            pulumi.set(__self__, "help", help)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if parents is not None:
            pulumi.set(__self__, "parents", parents)
        if verbose is not None:
            pulumi.set(__self__, "verbose", verbose)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def directory(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "directory")

    @directory.setter
    def directory(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "directory", value)

    @property
    @pulumi.getter
    def help(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "help")

    @help.setter
    def help(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "help", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter
    def parents(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "parents")

    @parents.setter
    def parents(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "parents", value)

    @property
    @pulumi.getter
    def verbose(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "verbose")

    @verbose.setter
    def verbose(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verbose", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class MktempArgsArgs:
    def __init__(__self__, *,
                 directory: Optional[pulumi.Input[bool]] = None,
                 dry_run: Optional[pulumi.Input[bool]] = None,
                 help: Optional[pulumi.Input[bool]] = None,
                 p: Optional[pulumi.Input[str]] = None,
                 quiet: Optional[pulumi.Input[bool]] = None,
                 suffix: Optional[pulumi.Input[str]] = None,
                 t: Optional[pulumi.Input[bool]] = None,
                 template: Optional[pulumi.Input[str]] = None,
                 tmpdir: Optional[pulumi.Input[bool]] = None,
                 version: Optional[pulumi.Input[bool]] = None):
        if directory is not None:
            pulumi.set(__self__, "directory", directory)
        if dry_run is not None:
            pulumi.set(__self__, "dry_run", dry_run)
        if help is not None:
            pulumi.set(__self__, "help", help)
        if p is not None:
            pulumi.set(__self__, "p", p)
        if quiet is not None:
            pulumi.set(__self__, "quiet", quiet)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)
        if t is not None:
            pulumi.set(__self__, "t", t)
        if template is not None:
            pulumi.set(__self__, "template", template)
        if tmpdir is not None:
            pulumi.set(__self__, "tmpdir", tmpdir)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def directory(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "directory")

    @directory.setter
    def directory(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "directory", value)

    @property
    @pulumi.getter(name="dryRun")
    def dry_run(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "dry_run")

    @dry_run.setter
    def dry_run(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "dry_run", value)

    @property
    @pulumi.getter
    def help(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "help")

    @help.setter
    def help(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "help", value)

    @property
    @pulumi.getter
    def p(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "p")

    @p.setter
    def p(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "p", value)

    @property
    @pulumi.getter
    def quiet(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "quiet")

    @quiet.setter
    def quiet(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "quiet", value)

    @property
    @pulumi.getter
    def suffix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "suffix")

    @suffix.setter
    def suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "suffix", value)

    @property
    @pulumi.getter
    def t(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "t")

    @t.setter
    def t(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "t", value)

    @property
    @pulumi.getter
    def template(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "template")

    @template.setter
    def template(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "template", value)

    @property
    @pulumi.getter
    def tmpdir(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "tmpdir")

    @tmpdir.setter
    def tmpdir(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "tmpdir", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class MvArgsArgs:
    def __init__(__self__, *,
                 source: pulumi.Input[Sequence[pulumi.Input[str]]],
                 backup: Optional[pulumi.Input[str]] = None,
                 destination: Optional[pulumi.Input[str]] = None,
                 directory: Optional[pulumi.Input[str]] = None,
                 force: Optional[pulumi.Input[bool]] = None,
                 help: Optional[pulumi.Input[bool]] = None,
                 no_clobber: Optional[pulumi.Input[bool]] = None,
                 no_target_directory: Optional[pulumi.Input[bool]] = None,
                 strip_trailing_slashes: Optional[pulumi.Input[bool]] = None,
                 suffix: Optional[pulumi.Input[str]] = None,
                 target_directory: Optional[pulumi.Input[str]] = None,
                 update: Optional[pulumi.Input[bool]] = None,
                 verbose: Optional[pulumi.Input[bool]] = None,
                 version: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "source", source)
        if backup is not None:
            pulumi.set(__self__, "backup", backup)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if directory is not None:
            pulumi.set(__self__, "directory", directory)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if help is not None:
            pulumi.set(__self__, "help", help)
        if no_clobber is not None:
            pulumi.set(__self__, "no_clobber", no_clobber)
        if no_target_directory is not None:
            pulumi.set(__self__, "no_target_directory", no_target_directory)
        if strip_trailing_slashes is not None:
            pulumi.set(__self__, "strip_trailing_slashes", strip_trailing_slashes)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)
        if target_directory is not None:
            pulumi.set(__self__, "target_directory", target_directory)
        if update is not None:
            pulumi.set(__self__, "update", update)
        if verbose is not None:
            pulumi.set(__self__, "verbose", verbose)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def source(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter
    def backup(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "backup")

    @backup.setter
    def backup(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "backup", value)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "destination", value)

    @property
    @pulumi.getter
    def directory(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "directory")

    @directory.setter
    def directory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "directory", value)

    @property
    @pulumi.getter
    def force(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "force")

    @force.setter
    def force(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force", value)

    @property
    @pulumi.getter
    def help(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "help")

    @help.setter
    def help(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "help", value)

    @property
    @pulumi.getter(name="noClobber")
    def no_clobber(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_clobber")

    @no_clobber.setter
    def no_clobber(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_clobber", value)

    @property
    @pulumi.getter(name="noTargetDirectory")
    def no_target_directory(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_target_directory")

    @no_target_directory.setter
    def no_target_directory(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_target_directory", value)

    @property
    @pulumi.getter(name="stripTrailingSlashes")
    def strip_trailing_slashes(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "strip_trailing_slashes")

    @strip_trailing_slashes.setter
    def strip_trailing_slashes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strip_trailing_slashes", value)

    @property
    @pulumi.getter
    def suffix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "suffix")

    @suffix.setter
    def suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "suffix", value)

    @property
    @pulumi.getter(name="targetDirectory")
    def target_directory(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "target_directory")

    @target_directory.setter
    def target_directory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target_directory", value)

    @property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "update")

    @update.setter
    def update(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "update", value)

    @property
    @pulumi.getter
    def verbose(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "verbose")

    @verbose.setter
    def verbose(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verbose", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "version", value)


@pulumi.input_type
class RmArgsArgs:
    def __init__(__self__, *,
                 files: pulumi.Input[Sequence[pulumi.Input[str]]],
                 dir: Optional[pulumi.Input[bool]] = None,
                 force: Optional[pulumi.Input[bool]] = None,
                 help: Optional[pulumi.Input[bool]] = None,
                 one_file_system: Optional[pulumi.Input[bool]] = None,
                 recursive: Optional[pulumi.Input[bool]] = None,
                 verbose: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "files", files)
        if dir is not None:
            pulumi.set(__self__, "dir", dir)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if help is not None:
            pulumi.set(__self__, "help", help)
        if one_file_system is not None:
            pulumi.set(__self__, "one_file_system", one_file_system)
        if recursive is not None:
            pulumi.set(__self__, "recursive", recursive)
        if verbose is not None:
            pulumi.set(__self__, "verbose", verbose)

    @property
    @pulumi.getter
    def files(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "files")

    @files.setter
    def files(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "files", value)

    @property
    @pulumi.getter
    def dir(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "dir")

    @dir.setter
    def dir(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "dir", value)

    @property
    @pulumi.getter
    def force(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "force")

    @force.setter
    def force(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force", value)

    @property
    @pulumi.getter
    def help(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "help")

    @help.setter
    def help(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "help", value)

    @property
    @pulumi.getter(name="oneFileSystem")
    def one_file_system(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "one_file_system")

    @one_file_system.setter
    def one_file_system(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "one_file_system", value)

    @property
    @pulumi.getter
    def recursive(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "recursive")

    @recursive.setter
    def recursive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "recursive", value)

    @property
    @pulumi.getter
    def verbose(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "verbose")

    @verbose.setter
    def verbose(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verbose", value)


@pulumi.input_type
class TarArgsArgs:
    def __init__(__self__, *,
                 append: Optional[pulumi.Input[bool]] = None,
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 bzip2: Optional[pulumi.Input[bool]] = None,
                 create: Optional[pulumi.Input[bool]] = None,
                 delete: Optional[pulumi.Input[bool]] = None,
                 diff: Optional[pulumi.Input[bool]] = None,
                 directory: Optional[pulumi.Input[str]] = None,
                 exclude: Optional[pulumi.Input[str]] = None,
                 exclude_from: Optional[pulumi.Input[str]] = None,
                 exclude_vcs: Optional[pulumi.Input[bool]] = None,
                 exclude_vcs_ignores: Optional[pulumi.Input[bool]] = None,
                 extract: Optional[pulumi.Input[bool]] = None,
                 file: Optional[pulumi.Input[str]] = None,
                 gzip: Optional[pulumi.Input[bool]] = None,
                 ignore_command_error: Optional[pulumi.Input[bool]] = None,
                 keep_directory_symlink: Optional[pulumi.Input[bool]] = None,
                 keep_newer_files: Optional[pulumi.Input[bool]] = None,
                 keep_oldfiles: Optional[pulumi.Input[bool]] = None,
                 list: Optional[pulumi.Input[bool]] = None,
                 lzip: Optional[pulumi.Input[bool]] = None,
                 lzma: Optional[pulumi.Input[bool]] = None,
                 lzop: Optional[pulumi.Input[bool]] = None,
                 no_overwrite_dir: Optional[pulumi.Input[bool]] = None,
                 no_seek: Optional[pulumi.Input[bool]] = None,
                 overwrite: Optional[pulumi.Input[bool]] = None,
                 overwrite_dir: Optional[pulumi.Input[bool]] = None,
                 remove_files: Optional[pulumi.Input[bool]] = None,
                 skip_old_files: Optional[pulumi.Input[bool]] = None,
                 sparse: Optional[pulumi.Input[bool]] = None,
                 strip_components: Optional[pulumi.Input[int]] = None,
                 suffix: Optional[pulumi.Input[str]] = None,
                 to_stdout: Optional[pulumi.Input[bool]] = None,
                 transform: Optional[pulumi.Input[str]] = None,
                 unlink_first: Optional[pulumi.Input[bool]] = None,
                 update: Optional[pulumi.Input[bool]] = None,
                 verbose: Optional[pulumi.Input[bool]] = None,
                 verify: Optional[pulumi.Input[bool]] = None,
                 xz: Optional[pulumi.Input[bool]] = None,
                 zstd: Optional[pulumi.Input[bool]] = None):
        if append is not None:
            pulumi.set(__self__, "append", append)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if bzip2 is not None:
            pulumi.set(__self__, "bzip2", bzip2)
        if create is not None:
            pulumi.set(__self__, "create", create)
        if delete is not None:
            pulumi.set(__self__, "delete", delete)
        if diff is not None:
            pulumi.set(__self__, "diff", diff)
        if directory is not None:
            pulumi.set(__self__, "directory", directory)
        if exclude is not None:
            pulumi.set(__self__, "exclude", exclude)
        if exclude_from is not None:
            pulumi.set(__self__, "exclude_from", exclude_from)
        if exclude_vcs is not None:
            pulumi.set(__self__, "exclude_vcs", exclude_vcs)
        if exclude_vcs_ignores is not None:
            pulumi.set(__self__, "exclude_vcs_ignores", exclude_vcs_ignores)
        if extract is not None:
            pulumi.set(__self__, "extract", extract)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if gzip is not None:
            pulumi.set(__self__, "gzip", gzip)
        if ignore_command_error is not None:
            pulumi.set(__self__, "ignore_command_error", ignore_command_error)
        if keep_directory_symlink is not None:
            pulumi.set(__self__, "keep_directory_symlink", keep_directory_symlink)
        if keep_newer_files is not None:
            pulumi.set(__self__, "keep_newer_files", keep_newer_files)
        if keep_oldfiles is not None:
            pulumi.set(__self__, "keep_oldfiles", keep_oldfiles)
        if list is not None:
            pulumi.set(__self__, "list", list)
        if lzip is not None:
            pulumi.set(__self__, "lzip", lzip)
        if lzma is not None:
            pulumi.set(__self__, "lzma", lzma)
        if lzop is not None:
            pulumi.set(__self__, "lzop", lzop)
        if no_overwrite_dir is not None:
            pulumi.set(__self__, "no_overwrite_dir", no_overwrite_dir)
        if no_seek is not None:
            pulumi.set(__self__, "no_seek", no_seek)
        if overwrite is not None:
            pulumi.set(__self__, "overwrite", overwrite)
        if overwrite_dir is not None:
            pulumi.set(__self__, "overwrite_dir", overwrite_dir)
        if remove_files is not None:
            pulumi.set(__self__, "remove_files", remove_files)
        if skip_old_files is not None:
            pulumi.set(__self__, "skip_old_files", skip_old_files)
        if sparse is not None:
            pulumi.set(__self__, "sparse", sparse)
        if strip_components is not None:
            pulumi.set(__self__, "strip_components", strip_components)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)
        if to_stdout is not None:
            pulumi.set(__self__, "to_stdout", to_stdout)
        if transform is not None:
            pulumi.set(__self__, "transform", transform)
        if unlink_first is not None:
            pulumi.set(__self__, "unlink_first", unlink_first)
        if update is not None:
            pulumi.set(__self__, "update", update)
        if verbose is not None:
            pulumi.set(__self__, "verbose", verbose)
        if verify is not None:
            pulumi.set(__self__, "verify", verify)
        if xz is not None:
            pulumi.set(__self__, "xz", xz)
        if zstd is not None:
            pulumi.set(__self__, "zstd", zstd)

    @property
    @pulumi.getter
    def append(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "append")

    @append.setter
    def append(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "append", value)

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "args")

    @args.setter
    def args(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "args", value)

    @property
    @pulumi.getter
    def bzip2(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "bzip2")

    @bzip2.setter
    def bzip2(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "bzip2", value)

    @property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "create")

    @create.setter
    def create(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create", value)

    @property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "delete")

    @delete.setter
    def delete(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "delete", value)

    @property
    @pulumi.getter
    def diff(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "diff")

    @diff.setter
    def diff(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "diff", value)

    @property
    @pulumi.getter
    def directory(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "directory")

    @directory.setter
    def directory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "directory", value)

    @property
    @pulumi.getter
    def exclude(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "exclude")

    @exclude.setter
    def exclude(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exclude", value)

    @property
    @pulumi.getter(name="excludeFrom")
    def exclude_from(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "exclude_from")

    @exclude_from.setter
    def exclude_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exclude_from", value)

    @property
    @pulumi.getter(name="excludeVcs")
    def exclude_vcs(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "exclude_vcs")

    @exclude_vcs.setter
    def exclude_vcs(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "exclude_vcs", value)

    @property
    @pulumi.getter(name="excludeVcsIgnores")
    def exclude_vcs_ignores(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "exclude_vcs_ignores")

    @exclude_vcs_ignores.setter
    def exclude_vcs_ignores(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "exclude_vcs_ignores", value)

    @property
    @pulumi.getter
    def extract(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "extract")

    @extract.setter
    def extract(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "extract", value)

    @property
    @pulumi.getter
    def file(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "file")

    @file.setter
    def file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "file", value)

    @property
    @pulumi.getter
    def gzip(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "gzip")

    @gzip.setter
    def gzip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gzip", value)

    @property
    @pulumi.getter(name="ignoreCommandError")
    def ignore_command_error(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "ignore_command_error")

    @ignore_command_error.setter
    def ignore_command_error(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_command_error", value)

    @property
    @pulumi.getter(name="keepDirectorySymlink")
    def keep_directory_symlink(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "keep_directory_symlink")

    @keep_directory_symlink.setter
    def keep_directory_symlink(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "keep_directory_symlink", value)

    @property
    @pulumi.getter(name="keepNewerFiles")
    def keep_newer_files(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "keep_newer_files")

    @keep_newer_files.setter
    def keep_newer_files(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "keep_newer_files", value)

    @property
    @pulumi.getter(name="keepOldfiles")
    def keep_oldfiles(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "keep_oldfiles")

    @keep_oldfiles.setter
    def keep_oldfiles(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "keep_oldfiles", value)

    @property
    @pulumi.getter
    def list(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "list")

    @list.setter
    def list(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "list", value)

    @property
    @pulumi.getter
    def lzip(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "lzip")

    @lzip.setter
    def lzip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lzip", value)

    @property
    @pulumi.getter
    def lzma(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "lzma")

    @lzma.setter
    def lzma(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lzma", value)

    @property
    @pulumi.getter
    def lzop(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "lzop")

    @lzop.setter
    def lzop(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "lzop", value)

    @property
    @pulumi.getter(name="noOverwriteDir")
    def no_overwrite_dir(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_overwrite_dir")

    @no_overwrite_dir.setter
    def no_overwrite_dir(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_overwrite_dir", value)

    @property
    @pulumi.getter(name="noSeek")
    def no_seek(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_seek")

    @no_seek.setter
    def no_seek(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_seek", value)

    @property
    @pulumi.getter
    def overwrite(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "overwrite")

    @overwrite.setter
    def overwrite(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "overwrite", value)

    @property
    @pulumi.getter(name="overwriteDir")
    def overwrite_dir(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "overwrite_dir")

    @overwrite_dir.setter
    def overwrite_dir(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "overwrite_dir", value)

    @property
    @pulumi.getter(name="removeFiles")
    def remove_files(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "remove_files")

    @remove_files.setter
    def remove_files(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "remove_files", value)

    @property
    @pulumi.getter(name="skipOldFiles")
    def skip_old_files(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "skip_old_files")

    @skip_old_files.setter
    def skip_old_files(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "skip_old_files", value)

    @property
    @pulumi.getter
    def sparse(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "sparse")

    @sparse.setter
    def sparse(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sparse", value)

    @property
    @pulumi.getter(name="stripComponents")
    def strip_components(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "strip_components")

    @strip_components.setter
    def strip_components(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "strip_components", value)

    @property
    @pulumi.getter
    def suffix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "suffix")

    @suffix.setter
    def suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "suffix", value)

    @property
    @pulumi.getter(name="toStdout")
    def to_stdout(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "to_stdout")

    @to_stdout.setter
    def to_stdout(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "to_stdout", value)

    @property
    @pulumi.getter
    def transform(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "transform")

    @transform.setter
    def transform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "transform", value)

    @property
    @pulumi.getter(name="unlinkFirst")
    def unlink_first(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "unlink_first")

    @unlink_first.setter
    def unlink_first(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "unlink_first", value)

    @property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "update")

    @update.setter
    def update(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "update", value)

    @property
    @pulumi.getter
    def verbose(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "verbose")

    @verbose.setter
    def verbose(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verbose", value)

    @property
    @pulumi.getter
    def verify(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "verify")

    @verify.setter
    def verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verify", value)

    @property
    @pulumi.getter
    def xz(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "xz")

    @xz.setter
    def xz(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "xz", value)

    @property
    @pulumi.getter
    def zstd(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "zstd")

    @zstd.setter
    def zstd(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "zstd", value)


@pulumi.input_type
class TeeArgsArgs:
    def __init__(__self__, *,
                 files: pulumi.Input[Sequence[pulumi.Input[str]]],
                 append: Optional[pulumi.Input[bool]] = None,
                 stdin: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "files", files)
        if append is not None:
            pulumi.set(__self__, "append", append)
        if stdin is not None:
            pulumi.set(__self__, "stdin", stdin)

    @property
    @pulumi.getter
    def files(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "files")

    @files.setter
    def files(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "files", value)

    @property
    @pulumi.getter
    def append(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "append")

    @append.setter
    def append(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "append", value)

    @property
    @pulumi.getter
    def stdin(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stdin")

    @stdin.setter
    def stdin(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stdin", value)


@pulumi.input_type
class WgetArgsArgs:
    def __init__(__self__, *,
                 urls: pulumi.Input[Sequence[pulumi.Input[str]]],
                 append_output: Optional[pulumi.Input[str]] = None,
                 background: Optional[pulumi.Input[bool]] = None,
                 base: Optional[pulumi.Input[str]] = None,
                 ca_certificate_file: Optional[pulumi.Input[str]] = None,
                 ca_directory: Optional[pulumi.Input[str]] = None,
                 certificate: Optional[pulumi.Input[str]] = None,
                 certificate_type: Optional[pulumi.Input[str]] = None,
                 config: Optional[pulumi.Input[str]] = None,
                 continue_: Optional[pulumi.Input[bool]] = None,
                 crl_file: Optional[pulumi.Input[str]] = None,
                 cut_dirs: Optional[pulumi.Input[int]] = None,
                 debug: Optional[pulumi.Input[bool]] = None,
                 directory_prefix: Optional[pulumi.Input[str]] = None,
                 execute: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 force_directories: Optional[pulumi.Input[bool]] = None,
                 force_html: Optional[pulumi.Input[bool]] = None,
                 help: Optional[pulumi.Input[bool]] = None,
                 https_only: Optional[pulumi.Input[bool]] = None,
                 inet4_only: Optional[pulumi.Input[bool]] = None,
                 input_file: Optional[pulumi.Input[str]] = None,
                 keep_session_cookies: Optional[pulumi.Input[bool]] = None,
                 no_clobber: Optional[pulumi.Input[bool]] = None,
                 no_directories: Optional[pulumi.Input[bool]] = None,
                 no_dns_cache: Optional[pulumi.Input[bool]] = None,
                 no_verbose: Optional[pulumi.Input[bool]] = None,
                 output_document: Optional[pulumi.Input[str]] = None,
                 output_file: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 private_key: Optional[pulumi.Input[str]] = None,
                 private_key_type: Optional[pulumi.Input[str]] = None,
                 progress: Optional[pulumi.Input[str]] = None,
                 quiet: Optional[pulumi.Input[bool]] = None,
                 random_wait: Optional[pulumi.Input[bool]] = None,
                 report_speed: Optional[pulumi.Input[str]] = None,
                 save_cookies: Optional[pulumi.Input[str]] = None,
                 show_progress: Optional[pulumi.Input[bool]] = None,
                 start_pos: Optional[pulumi.Input[str]] = None,
                 timeout: Optional[pulumi.Input[str]] = None,
                 timestamping: Optional[pulumi.Input[bool]] = None,
                 tries: Optional[pulumi.Input[int]] = None,
                 user: Optional[pulumi.Input[str]] = None,
                 user_agent: Optional[pulumi.Input[str]] = None,
                 verbose: Optional[pulumi.Input[bool]] = None,
                 version: Optional[pulumi.Input[str]] = None,
                 wait: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "urls", urls)
        if append_output is not None:
            pulumi.set(__self__, "append_output", append_output)
        if background is not None:
            pulumi.set(__self__, "background", background)
        if base is not None:
            pulumi.set(__self__, "base", base)
        if ca_certificate_file is not None:
            pulumi.set(__self__, "ca_certificate_file", ca_certificate_file)
        if ca_directory is not None:
            pulumi.set(__self__, "ca_directory", ca_directory)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if certificate_type is not None:
            pulumi.set(__self__, "certificate_type", certificate_type)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if continue_ is not None:
            pulumi.set(__self__, "continue_", continue_)
        if crl_file is not None:
            pulumi.set(__self__, "crl_file", crl_file)
        if cut_dirs is not None:
            pulumi.set(__self__, "cut_dirs", cut_dirs)
        if debug is not None:
            pulumi.set(__self__, "debug", debug)
        if directory_prefix is not None:
            pulumi.set(__self__, "directory_prefix", directory_prefix)
        if execute is not None:
            pulumi.set(__self__, "execute", execute)
        if force_directories is not None:
            pulumi.set(__self__, "force_directories", force_directories)
        if force_html is not None:
            pulumi.set(__self__, "force_html", force_html)
        if help is not None:
            pulumi.set(__self__, "help", help)
        if https_only is not None:
            pulumi.set(__self__, "https_only", https_only)
        if inet4_only is not None:
            pulumi.set(__self__, "inet4_only", inet4_only)
        if input_file is not None:
            pulumi.set(__self__, "input_file", input_file)
        if keep_session_cookies is not None:
            pulumi.set(__self__, "keep_session_cookies", keep_session_cookies)
        if no_clobber is not None:
            pulumi.set(__self__, "no_clobber", no_clobber)
        if no_directories is not None:
            pulumi.set(__self__, "no_directories", no_directories)
        if no_dns_cache is not None:
            pulumi.set(__self__, "no_dns_cache", no_dns_cache)
        if no_verbose is not None:
            pulumi.set(__self__, "no_verbose", no_verbose)
        if output_document is not None:
            pulumi.set(__self__, "output_document", output_document)
        if output_file is not None:
            pulumi.set(__self__, "output_file", output_file)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key is not None:
            pulumi.set(__self__, "private_key", private_key)
        if private_key_type is not None:
            pulumi.set(__self__, "private_key_type", private_key_type)
        if progress is not None:
            pulumi.set(__self__, "progress", progress)
        if quiet is not None:
            pulumi.set(__self__, "quiet", quiet)
        if random_wait is not None:
            pulumi.set(__self__, "random_wait", random_wait)
        if report_speed is not None:
            pulumi.set(__self__, "report_speed", report_speed)
        if save_cookies is not None:
            pulumi.set(__self__, "save_cookies", save_cookies)
        if show_progress is not None:
            pulumi.set(__self__, "show_progress", show_progress)
        if start_pos is not None:
            pulumi.set(__self__, "start_pos", start_pos)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if timestamping is not None:
            pulumi.set(__self__, "timestamping", timestamping)
        if tries is not None:
            pulumi.set(__self__, "tries", tries)
        if user is not None:
            pulumi.set(__self__, "user", user)
        if user_agent is not None:
            pulumi.set(__self__, "user_agent", user_agent)
        if verbose is not None:
            pulumi.set(__self__, "verbose", verbose)
        if version is not None:
            pulumi.set(__self__, "version", version)
        if wait is not None:
            pulumi.set(__self__, "wait", wait)

    @property
    @pulumi.getter
    def urls(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "urls")

    @urls.setter
    def urls(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "urls", value)

    @property
    @pulumi.getter(name="appendOutput")
    def append_output(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "append_output")

    @append_output.setter
    def append_output(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "append_output", value)

    @property
    @pulumi.getter
    def background(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "background")

    @background.setter
    def background(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "background", value)

    @property
    @pulumi.getter
    def base(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "base")

    @base.setter
    def base(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "base", value)

    @property
    @pulumi.getter(name="caCertificateFile")
    def ca_certificate_file(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ca_certificate_file")

    @ca_certificate_file.setter
    def ca_certificate_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_certificate_file", value)

    @property
    @pulumi.getter(name="caDirectory")
    def ca_directory(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ca_directory")

    @ca_directory.setter
    def ca_directory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_directory", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="certificateType")
    def certificate_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "certificate_type")

    @certificate_type.setter
    def certificate_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate_type", value)

    @property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "config", value)

    @property
    @pulumi.getter(name="continue")
    def continue_(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "continue_")

    @continue_.setter
    def continue_(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "continue_", value)

    @property
    @pulumi.getter(name="crlFile")
    def crl_file(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "crl_file")

    @crl_file.setter
    def crl_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "crl_file", value)

    @property
    @pulumi.getter(name="cutDirs")
    def cut_dirs(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "cut_dirs")

    @cut_dirs.setter
    def cut_dirs(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cut_dirs", value)

    @property
    @pulumi.getter
    def debug(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "debug")

    @debug.setter
    def debug(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "debug", value)

    @property
    @pulumi.getter(name="directoryPrefix")
    def directory_prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "directory_prefix")

    @directory_prefix.setter
    def directory_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "directory_prefix", value)

    @property
    @pulumi.getter
    def execute(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "execute")

    @execute.setter
    def execute(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "execute", value)

    @property
    @pulumi.getter(name="forceDirectories")
    def force_directories(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "force_directories")

    @force_directories.setter
    def force_directories(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force_directories", value)

    @property
    @pulumi.getter(name="forceHtml")
    def force_html(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "force_html")

    @force_html.setter
    def force_html(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "force_html", value)

    @property
    @pulumi.getter
    def help(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "help")

    @help.setter
    def help(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "help", value)

    @property
    @pulumi.getter(name="httpsOnly")
    def https_only(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "https_only")

    @https_only.setter
    def https_only(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_only", value)

    @property
    @pulumi.getter(name="inet4Only")
    def inet4_only(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "inet4_only")

    @inet4_only.setter
    def inet4_only(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "inet4_only", value)

    @property
    @pulumi.getter(name="inputFile")
    def input_file(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_file")

    @input_file.setter
    def input_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_file", value)

    @property
    @pulumi.getter(name="keepSessionCookies")
    def keep_session_cookies(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "keep_session_cookies")

    @keep_session_cookies.setter
    def keep_session_cookies(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "keep_session_cookies", value)

    @property
    @pulumi.getter(name="noClobber")
    def no_clobber(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_clobber")

    @no_clobber.setter
    def no_clobber(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_clobber", value)

    @property
    @pulumi.getter(name="noDirectories")
    def no_directories(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_directories")

    @no_directories.setter
    def no_directories(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_directories", value)

    @property
    @pulumi.getter(name="noDnsCache")
    def no_dns_cache(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_dns_cache")

    @no_dns_cache.setter
    def no_dns_cache(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_dns_cache", value)

    @property
    @pulumi.getter(name="noVerbose")
    def no_verbose(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "no_verbose")

    @no_verbose.setter
    def no_verbose(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_verbose", value)

    @property
    @pulumi.getter(name="outputDocument")
    def output_document(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "output_document")

    @output_document.setter
    def output_document(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_document", value)

    @property
    @pulumi.getter(name="outputFile")
    def output_file(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "output_file")

    @output_file.setter
    def output_file(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_file", value)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "private_key")

    @private_key.setter
    def private_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_key", value)

    @property
    @pulumi.getter(name="privateKeyType")
    def private_key_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "private_key_type")

    @private_key_type.setter
    def private_key_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_key_type", value)

    @property
    @pulumi.getter
    def progress(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "progress")

    @progress.setter
    def progress(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "progress", value)

    @property
    @pulumi.getter
    def quiet(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "quiet")

    @quiet.setter
    def quiet(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "quiet", value)

    @property
    @pulumi.getter(name="randomWait")
    def random_wait(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "random_wait")

    @random_wait.setter
    def random_wait(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "random_wait", value)

    @property
    @pulumi.getter(name="reportSpeed")
    def report_speed(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "report_speed")

    @report_speed.setter
    def report_speed(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "report_speed", value)

    @property
    @pulumi.getter(name="saveCookies")
    def save_cookies(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "save_cookies")

    @save_cookies.setter
    def save_cookies(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "save_cookies", value)

    @property
    @pulumi.getter(name="showProgress")
    def show_progress(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "show_progress")

    @show_progress.setter
    def show_progress(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "show_progress", value)

    @property
    @pulumi.getter(name="startPos")
    def start_pos(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "start_pos")

    @start_pos.setter
    def start_pos(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start_pos", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter
    def timestamping(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "timestamping")

    @timestamping.setter
    def timestamping(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "timestamping", value)

    @property
    @pulumi.getter
    def tries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "tries")

    @tries.setter
    def tries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tries", value)

    @property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user", value)

    @property
    @pulumi.getter(name="userAgent")
    def user_agent(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "user_agent")

    @user_agent.setter
    def user_agent(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_agent", value)

    @property
    @pulumi.getter
    def verbose(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "verbose")

    @verbose.setter
    def verbose(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verbose", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)

    @property
    @pulumi.getter
    def wait(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "wait")

    @wait.setter
    def wait(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "wait", value)


