# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** 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, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'ContainerCloneArgs',
    'ContainerConsoleArgs',
    'ContainerCpuArgs',
    'ContainerDiskArgs',
    'ContainerFeaturesArgs',
    'ContainerInitializationArgs',
    'ContainerInitializationDnsArgs',
    'ContainerInitializationIpConfigArgs',
    'ContainerInitializationIpConfigIpv4Args',
    'ContainerInitializationIpConfigIpv6Args',
    'ContainerInitializationUserAccountArgs',
    'ContainerMemoryArgs',
    'ContainerMountPointArgs',
    'ContainerNetworkInterfaceArgs',
    'ContainerOperatingSystemArgs',
]

@pulumi.input_type
class ContainerCloneArgs:
    def __init__(__self__, *,
                 vm_id: pulumi.Input[int],
                 datastore_id: Optional[pulumi.Input[str]] = None,
                 node_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] vm_id: The container identifier
        :param pulumi.Input[str] datastore_id: The identifier for the datastore to create the
               disk in (defaults to `local`).
        :param pulumi.Input[str] node_name: The name of the node to assign the container to.
        """
        ContainerCloneArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            vm_id=vm_id,
            datastore_id=datastore_id,
            node_name=node_name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             vm_id: pulumi.Input[int],
             datastore_id: Optional[pulumi.Input[str]] = None,
             node_name: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'vmId' in kwargs:
            vm_id = kwargs['vmId']
        if 'datastoreId' in kwargs:
            datastore_id = kwargs['datastoreId']
        if 'nodeName' in kwargs:
            node_name = kwargs['nodeName']

        _setter("vm_id", vm_id)
        if datastore_id is not None:
            _setter("datastore_id", datastore_id)
        if node_name is not None:
            _setter("node_name", node_name)

    @property
    @pulumi.getter(name="vmId")
    def vm_id(self) -> pulumi.Input[int]:
        """
        The container identifier
        """
        return pulumi.get(self, "vm_id")

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

    @property
    @pulumi.getter(name="datastoreId")
    def datastore_id(self) -> Optional[pulumi.Input[str]]:
        """
        The identifier for the datastore to create the
        disk in (defaults to `local`).
        """
        return pulumi.get(self, "datastore_id")

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

    @property
    @pulumi.getter(name="nodeName")
    def node_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the node to assign the container to.
        """
        return pulumi.get(self, "node_name")

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


@pulumi.input_type
class ContainerConsoleArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 tty_count: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enabled: Whether to enable the network device (defaults
               to `true`).
        :param pulumi.Input[int] tty_count: The number of available TTY (defaults to `2`).
        :param pulumi.Input[str] type: The type (defaults to `unmanaged`).
        """
        ContainerConsoleArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            enabled=enabled,
            tty_count=tty_count,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             enabled: Optional[pulumi.Input[bool]] = None,
             tty_count: Optional[pulumi.Input[int]] = None,
             type: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'ttyCount' in kwargs:
            tty_count = kwargs['ttyCount']

        if enabled is not None:
            _setter("enabled", enabled)
        if tty_count is not None:
            _setter("tty_count", tty_count)
        if type is not None:
            _setter("type", type)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable the network device (defaults
        to `true`).
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="ttyCount")
    def tty_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of available TTY (defaults to `2`).
        """
        return pulumi.get(self, "tty_count")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type (defaults to `unmanaged`).
        """
        return pulumi.get(self, "type")

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


@pulumi.input_type
class ContainerCpuArgs:
    def __init__(__self__, *,
                 architecture: Optional[pulumi.Input[str]] = None,
                 cores: Optional[pulumi.Input[int]] = None,
                 units: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] architecture: The CPU architecture (defaults to `amd64`).
        :param pulumi.Input[int] cores: The number of CPU cores (defaults to `1`).
        :param pulumi.Input[int] units: The CPU units (defaults to `1024`).
        """
        ContainerCpuArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            architecture=architecture,
            cores=cores,
            units=units,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             architecture: Optional[pulumi.Input[str]] = None,
             cores: Optional[pulumi.Input[int]] = None,
             units: Optional[pulumi.Input[int]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if architecture is not None:
            _setter("architecture", architecture)
        if cores is not None:
            _setter("cores", cores)
        if units is not None:
            _setter("units", units)

    @property
    @pulumi.getter
    def architecture(self) -> Optional[pulumi.Input[str]]:
        """
        The CPU architecture (defaults to `amd64`).
        """
        return pulumi.get(self, "architecture")

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

    @property
    @pulumi.getter
    def cores(self) -> Optional[pulumi.Input[int]]:
        """
        The number of CPU cores (defaults to `1`).
        """
        return pulumi.get(self, "cores")

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

    @property
    @pulumi.getter
    def units(self) -> Optional[pulumi.Input[int]]:
        """
        The CPU units (defaults to `1024`).
        """
        return pulumi.get(self, "units")

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


@pulumi.input_type
class ContainerDiskArgs:
    def __init__(__self__, *,
                 datastore_id: Optional[pulumi.Input[str]] = None,
                 size: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] datastore_id: The identifier for the datastore to create the
               disk in (defaults to `local`).
        :param pulumi.Input[int] size: Volume size (only for ZFS storage backed mount points).
               Can be specified with a unit suffix (e.g. `10G`).
        """
        ContainerDiskArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            datastore_id=datastore_id,
            size=size,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             datastore_id: Optional[pulumi.Input[str]] = None,
             size: Optional[pulumi.Input[int]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'datastoreId' in kwargs:
            datastore_id = kwargs['datastoreId']

        if datastore_id is not None:
            _setter("datastore_id", datastore_id)
        if size is not None:
            _setter("size", size)

    @property
    @pulumi.getter(name="datastoreId")
    def datastore_id(self) -> Optional[pulumi.Input[str]]:
        """
        The identifier for the datastore to create the
        disk in (defaults to `local`).
        """
        return pulumi.get(self, "datastore_id")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[int]]:
        """
        Volume size (only for ZFS storage backed mount points).
        Can be specified with a unit suffix (e.g. `10G`).
        """
        return pulumi.get(self, "size")

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


@pulumi.input_type
class ContainerFeaturesArgs:
    def __init__(__self__, *,
                 fuse: Optional[pulumi.Input[bool]] = None,
                 keyctl: Optional[pulumi.Input[bool]] = None,
                 nesting: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] fuse: Whether the container supports FUSE mounts (defaults
               to `false`)
        :param pulumi.Input[bool] keyctl: Whether the container supports `keyctl()` system
               call (defaults to `false`)
        :param pulumi.Input[bool] nesting: Whether the container is nested (defaults
               to `false`)
        """
        ContainerFeaturesArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            fuse=fuse,
            keyctl=keyctl,
            nesting=nesting,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             fuse: Optional[pulumi.Input[bool]] = None,
             keyctl: Optional[pulumi.Input[bool]] = None,
             nesting: Optional[pulumi.Input[bool]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if fuse is not None:
            _setter("fuse", fuse)
        if keyctl is not None:
            _setter("keyctl", keyctl)
        if nesting is not None:
            _setter("nesting", nesting)

    @property
    @pulumi.getter
    def fuse(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the container supports FUSE mounts (defaults
        to `false`)
        """
        return pulumi.get(self, "fuse")

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

    @property
    @pulumi.getter
    def keyctl(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the container supports `keyctl()` system
        call (defaults to `false`)
        """
        return pulumi.get(self, "keyctl")

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

    @property
    @pulumi.getter
    def nesting(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the container is nested (defaults
        to `false`)
        """
        return pulumi.get(self, "nesting")

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


@pulumi.input_type
class ContainerInitializationArgs:
    def __init__(__self__, *,
                 dns: Optional[pulumi.Input['ContainerInitializationDnsArgs']] = None,
                 hostname: Optional[pulumi.Input[str]] = None,
                 ip_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerInitializationIpConfigArgs']]]] = None,
                 user_account: Optional[pulumi.Input['ContainerInitializationUserAccountArgs']] = None):
        """
        :param pulumi.Input['ContainerInitializationDnsArgs'] dns: The DNS configuration.
        :param pulumi.Input[str] hostname: The hostname.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerInitializationIpConfigArgs']]] ip_configs: The IP configuration (one block per network
               device).
        :param pulumi.Input['ContainerInitializationUserAccountArgs'] user_account: The user account configuration.
        """
        ContainerInitializationArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            dns=dns,
            hostname=hostname,
            ip_configs=ip_configs,
            user_account=user_account,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             dns: Optional[pulumi.Input['ContainerInitializationDnsArgs']] = None,
             hostname: Optional[pulumi.Input[str]] = None,
             ip_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerInitializationIpConfigArgs']]]] = None,
             user_account: Optional[pulumi.Input['ContainerInitializationUserAccountArgs']] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'ipConfigs' in kwargs:
            ip_configs = kwargs['ipConfigs']
        if 'userAccount' in kwargs:
            user_account = kwargs['userAccount']

        if dns is not None:
            _setter("dns", dns)
        if hostname is not None:
            _setter("hostname", hostname)
        if ip_configs is not None:
            _setter("ip_configs", ip_configs)
        if user_account is not None:
            _setter("user_account", user_account)

    @property
    @pulumi.getter
    def dns(self) -> Optional[pulumi.Input['ContainerInitializationDnsArgs']]:
        """
        The DNS configuration.
        """
        return pulumi.get(self, "dns")

    @dns.setter
    def dns(self, value: Optional[pulumi.Input['ContainerInitializationDnsArgs']]):
        pulumi.set(self, "dns", value)

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

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

    @property
    @pulumi.getter(name="ipConfigs")
    def ip_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerInitializationIpConfigArgs']]]]:
        """
        The IP configuration (one block per network
        device).
        """
        return pulumi.get(self, "ip_configs")

    @ip_configs.setter
    def ip_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerInitializationIpConfigArgs']]]]):
        pulumi.set(self, "ip_configs", value)

    @property
    @pulumi.getter(name="userAccount")
    def user_account(self) -> Optional[pulumi.Input['ContainerInitializationUserAccountArgs']]:
        """
        The user account configuration.
        """
        return pulumi.get(self, "user_account")

    @user_account.setter
    def user_account(self, value: Optional[pulumi.Input['ContainerInitializationUserAccountArgs']]):
        pulumi.set(self, "user_account", value)


@pulumi.input_type
class ContainerInitializationDnsArgs:
    def __init__(__self__, *,
                 domain: Optional[pulumi.Input[str]] = None,
                 server: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] domain: The DNS search domain.
        :param pulumi.Input[str] server: The DNS server.
        """
        ContainerInitializationDnsArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            domain=domain,
            server=server,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             domain: Optional[pulumi.Input[str]] = None,
             server: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if domain is not None:
            _setter("domain", domain)
        if server is not None:
            _setter("server", server)

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

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

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

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


@pulumi.input_type
class ContainerInitializationIpConfigArgs:
    def __init__(__self__, *,
                 ipv4: Optional[pulumi.Input['ContainerInitializationIpConfigIpv4Args']] = None,
                 ipv6: Optional[pulumi.Input['ContainerInitializationIpConfigIpv6Args']] = None):
        """
        :param pulumi.Input['ContainerInitializationIpConfigIpv4Args'] ipv4: The IPv4 configuration.
        :param pulumi.Input['ContainerInitializationIpConfigIpv6Args'] ipv6: The IPv4 configuration.
        """
        ContainerInitializationIpConfigArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            ipv4=ipv4,
            ipv6=ipv6,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             ipv4: Optional[pulumi.Input['ContainerInitializationIpConfigIpv4Args']] = None,
             ipv6: Optional[pulumi.Input['ContainerInitializationIpConfigIpv6Args']] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if ipv4 is not None:
            _setter("ipv4", ipv4)
        if ipv6 is not None:
            _setter("ipv6", ipv6)

    @property
    @pulumi.getter
    def ipv4(self) -> Optional[pulumi.Input['ContainerInitializationIpConfigIpv4Args']]:
        """
        The IPv4 configuration.
        """
        return pulumi.get(self, "ipv4")

    @ipv4.setter
    def ipv4(self, value: Optional[pulumi.Input['ContainerInitializationIpConfigIpv4Args']]):
        pulumi.set(self, "ipv4", value)

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[pulumi.Input['ContainerInitializationIpConfigIpv6Args']]:
        """
        The IPv4 configuration.
        """
        return pulumi.get(self, "ipv6")

    @ipv6.setter
    def ipv6(self, value: Optional[pulumi.Input['ContainerInitializationIpConfigIpv6Args']]):
        pulumi.set(self, "ipv6", value)


@pulumi.input_type
class ContainerInitializationIpConfigIpv4Args:
    def __init__(__self__, *,
                 address: Optional[pulumi.Input[str]] = None,
                 gateway: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] address: The IPv6 address (use `dhcp` for
               autodiscovery).
        :param pulumi.Input[str] gateway: The IPv6 gateway (must be omitted
               when `dhcp` is used as the address).
        """
        ContainerInitializationIpConfigIpv4Args._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            address=address,
            gateway=gateway,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             address: Optional[pulumi.Input[str]] = None,
             gateway: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if address is not None:
            _setter("address", address)
        if gateway is not None:
            _setter("gateway", gateway)

    @property
    @pulumi.getter
    def address(self) -> Optional[pulumi.Input[str]]:
        """
        The IPv6 address (use `dhcp` for
        autodiscovery).
        """
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter
    def gateway(self) -> Optional[pulumi.Input[str]]:
        """
        The IPv6 gateway (must be omitted
        when `dhcp` is used as the address).
        """
        return pulumi.get(self, "gateway")

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


@pulumi.input_type
class ContainerInitializationIpConfigIpv6Args:
    def __init__(__self__, *,
                 address: Optional[pulumi.Input[str]] = None,
                 gateway: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] address: The IPv6 address (use `dhcp` for
               autodiscovery).
        :param pulumi.Input[str] gateway: The IPv6 gateway (must be omitted
               when `dhcp` is used as the address).
        """
        ContainerInitializationIpConfigIpv6Args._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            address=address,
            gateway=gateway,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             address: Optional[pulumi.Input[str]] = None,
             gateway: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if address is not None:
            _setter("address", address)
        if gateway is not None:
            _setter("gateway", gateway)

    @property
    @pulumi.getter
    def address(self) -> Optional[pulumi.Input[str]]:
        """
        The IPv6 address (use `dhcp` for
        autodiscovery).
        """
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter
    def gateway(self) -> Optional[pulumi.Input[str]]:
        """
        The IPv6 gateway (must be omitted
        when `dhcp` is used as the address).
        """
        return pulumi.get(self, "gateway")

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


@pulumi.input_type
class ContainerInitializationUserAccountArgs:
    def __init__(__self__, *,
                 keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 password: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] keys: The SSH keys for the root account.
        :param pulumi.Input[str] password: The password for the root account.
        """
        ContainerInitializationUserAccountArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            keys=keys,
            password=password,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             password: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if keys is not None:
            _setter("keys", keys)
        if password is not None:
            _setter("password", password)

    @property
    @pulumi.getter
    def keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The SSH keys for the root account.
        """
        return pulumi.get(self, "keys")

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

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

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


@pulumi.input_type
class ContainerMemoryArgs:
    def __init__(__self__, *,
                 dedicated: Optional[pulumi.Input[int]] = None,
                 swap: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] dedicated: The dedicated memory in megabytes (defaults
               to `512`).
        :param pulumi.Input[int] swap: The swap size in megabytes (defaults to `0`).
        """
        ContainerMemoryArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            dedicated=dedicated,
            swap=swap,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             dedicated: Optional[pulumi.Input[int]] = None,
             swap: Optional[pulumi.Input[int]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if dedicated is not None:
            _setter("dedicated", dedicated)
        if swap is not None:
            _setter("swap", swap)

    @property
    @pulumi.getter
    def dedicated(self) -> Optional[pulumi.Input[int]]:
        """
        The dedicated memory in megabytes (defaults
        to `512`).
        """
        return pulumi.get(self, "dedicated")

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

    @property
    @pulumi.getter
    def swap(self) -> Optional[pulumi.Input[int]]:
        """
        The swap size in megabytes (defaults to `0`).
        """
        return pulumi.get(self, "swap")

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


@pulumi.input_type
class ContainerMountPointArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str],
                 volume: pulumi.Input[str],
                 acl: Optional[pulumi.Input[bool]] = None,
                 backup: Optional[pulumi.Input[bool]] = None,
                 mount_options: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 quota: Optional[pulumi.Input[bool]] = None,
                 read_only: Optional[pulumi.Input[bool]] = None,
                 replicate: Optional[pulumi.Input[bool]] = None,
                 shared: Optional[pulumi.Input[bool]] = None,
                 size: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] path: Path to the mount point as seen from inside the
               container.
        :param pulumi.Input[str] volume: Volume, device or directory to mount into the
               container.
        :param pulumi.Input[bool] acl: Explicitly enable or disable ACL support.
        :param pulumi.Input[bool] backup: Whether to include the mount point in backups (only
               used for volume mount points).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] mount_options: List of extra mount options.
        :param pulumi.Input[bool] quota: Enable user quotas inside the container (not supported
               with ZFS subvolumes).
        :param pulumi.Input[bool] read_only: Read-only mount point.
        :param pulumi.Input[bool] replicate: Will include this volume to a storage replica job.
        :param pulumi.Input[bool] shared: Mark this non-volume mount point as available on all
               nodes.
        :param pulumi.Input[str] size: Volume size (only for ZFS storage backed mount points).
               Can be specified with a unit suffix (e.g. `10G`).
        """
        ContainerMountPointArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            path=path,
            volume=volume,
            acl=acl,
            backup=backup,
            mount_options=mount_options,
            quota=quota,
            read_only=read_only,
            replicate=replicate,
            shared=shared,
            size=size,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             path: pulumi.Input[str],
             volume: pulumi.Input[str],
             acl: Optional[pulumi.Input[bool]] = None,
             backup: Optional[pulumi.Input[bool]] = None,
             mount_options: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             quota: Optional[pulumi.Input[bool]] = None,
             read_only: Optional[pulumi.Input[bool]] = None,
             replicate: Optional[pulumi.Input[bool]] = None,
             shared: Optional[pulumi.Input[bool]] = None,
             size: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'mountOptions' in kwargs:
            mount_options = kwargs['mountOptions']
        if 'readOnly' in kwargs:
            read_only = kwargs['readOnly']

        _setter("path", path)
        _setter("volume", volume)
        if acl is not None:
            _setter("acl", acl)
        if backup is not None:
            _setter("backup", backup)
        if mount_options is not None:
            _setter("mount_options", mount_options)
        if quota is not None:
            _setter("quota", quota)
        if read_only is not None:
            _setter("read_only", read_only)
        if replicate is not None:
            _setter("replicate", replicate)
        if shared is not None:
            _setter("shared", shared)
        if size is not None:
            _setter("size", size)

    @property
    @pulumi.getter
    def path(self) -> pulumi.Input[str]:
        """
        Path to the mount point as seen from inside the
        container.
        """
        return pulumi.get(self, "path")

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

    @property
    @pulumi.getter
    def volume(self) -> pulumi.Input[str]:
        """
        Volume, device or directory to mount into the
        container.
        """
        return pulumi.get(self, "volume")

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

    @property
    @pulumi.getter
    def acl(self) -> Optional[pulumi.Input[bool]]:
        """
        Explicitly enable or disable ACL support.
        """
        return pulumi.get(self, "acl")

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

    @property
    @pulumi.getter
    def backup(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to include the mount point in backups (only
        used for volume mount points).
        """
        return pulumi.get(self, "backup")

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

    @property
    @pulumi.getter(name="mountOptions")
    def mount_options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of extra mount options.
        """
        return pulumi.get(self, "mount_options")

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

    @property
    @pulumi.getter
    def quota(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable user quotas inside the container (not supported
        with ZFS subvolumes).
        """
        return pulumi.get(self, "quota")

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

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[pulumi.Input[bool]]:
        """
        Read-only mount point.
        """
        return pulumi.get(self, "read_only")

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

    @property
    @pulumi.getter
    def replicate(self) -> Optional[pulumi.Input[bool]]:
        """
        Will include this volume to a storage replica job.
        """
        return pulumi.get(self, "replicate")

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

    @property
    @pulumi.getter
    def shared(self) -> Optional[pulumi.Input[bool]]:
        """
        Mark this non-volume mount point as available on all
        nodes.
        """
        return pulumi.get(self, "shared")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[str]]:
        """
        Volume size (only for ZFS storage backed mount points).
        Can be specified with a unit suffix (e.g. `10G`).
        """
        return pulumi.get(self, "size")

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


@pulumi.input_type
class ContainerNetworkInterfaceArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 bridge: Optional[pulumi.Input[str]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 firewall: Optional[pulumi.Input[bool]] = None,
                 mac_address: Optional[pulumi.Input[str]] = None,
                 mtu: Optional[pulumi.Input[int]] = None,
                 rate_limit: Optional[pulumi.Input[float]] = None,
                 vlan_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] name: The network interface name.
        :param pulumi.Input[str] bridge: The name of the network bridge (defaults
               to `vmbr0`).
        :param pulumi.Input[bool] enabled: Whether to enable the network device (defaults
               to `true`).
        :param pulumi.Input[bool] firewall: Whether this interface's firewall rules should be
               used (defaults to `false`).
        :param pulumi.Input[str] mac_address: The MAC address.
        :param pulumi.Input[int] mtu: Maximum transfer unit of the interface. Cannot be
               larger than the bridge's MTU.
        :param pulumi.Input[float] rate_limit: The rate limit in megabytes per second.
        :param pulumi.Input[int] vlan_id: The VLAN identifier.
        """
        ContainerNetworkInterfaceArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            name=name,
            bridge=bridge,
            enabled=enabled,
            firewall=firewall,
            mac_address=mac_address,
            mtu=mtu,
            rate_limit=rate_limit,
            vlan_id=vlan_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             name: pulumi.Input[str],
             bridge: Optional[pulumi.Input[str]] = None,
             enabled: Optional[pulumi.Input[bool]] = None,
             firewall: Optional[pulumi.Input[bool]] = None,
             mac_address: Optional[pulumi.Input[str]] = None,
             mtu: Optional[pulumi.Input[int]] = None,
             rate_limit: Optional[pulumi.Input[float]] = None,
             vlan_id: Optional[pulumi.Input[int]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'macAddress' in kwargs:
            mac_address = kwargs['macAddress']
        if 'rateLimit' in kwargs:
            rate_limit = kwargs['rateLimit']
        if 'vlanId' in kwargs:
            vlan_id = kwargs['vlanId']

        _setter("name", name)
        if bridge is not None:
            _setter("bridge", bridge)
        if enabled is not None:
            _setter("enabled", enabled)
        if firewall is not None:
            _setter("firewall", firewall)
        if mac_address is not None:
            _setter("mac_address", mac_address)
        if mtu is not None:
            _setter("mtu", mtu)
        if rate_limit is not None:
            _setter("rate_limit", rate_limit)
        if vlan_id is not None:
            _setter("vlan_id", vlan_id)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The network interface name.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def bridge(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the network bridge (defaults
        to `vmbr0`).
        """
        return pulumi.get(self, "bridge")

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable the network device (defaults
        to `true`).
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def firewall(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether this interface's firewall rules should be
        used (defaults to `false`).
        """
        return pulumi.get(self, "firewall")

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

    @property
    @pulumi.getter(name="macAddress")
    def mac_address(self) -> Optional[pulumi.Input[str]]:
        """
        The MAC address.
        """
        return pulumi.get(self, "mac_address")

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

    @property
    @pulumi.getter
    def mtu(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum transfer unit of the interface. Cannot be
        larger than the bridge's MTU.
        """
        return pulumi.get(self, "mtu")

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

    @property
    @pulumi.getter(name="rateLimit")
    def rate_limit(self) -> Optional[pulumi.Input[float]]:
        """
        The rate limit in megabytes per second.
        """
        return pulumi.get(self, "rate_limit")

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

    @property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> Optional[pulumi.Input[int]]:
        """
        The VLAN identifier.
        """
        return pulumi.get(self, "vlan_id")

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


@pulumi.input_type
class ContainerOperatingSystemArgs:
    def __init__(__self__, *,
                 template_file_id: pulumi.Input[str],
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] template_file_id: The identifier for an OS template file.
        :param pulumi.Input[str] type: The type (defaults to `unmanaged`).
        """
        ContainerOperatingSystemArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            template_file_id=template_file_id,
            type=type,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             template_file_id: pulumi.Input[str],
             type: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'templateFileId' in kwargs:
            template_file_id = kwargs['templateFileId']

        _setter("template_file_id", template_file_id)
        if type is not None:
            _setter("type", type)

    @property
    @pulumi.getter(name="templateFileId")
    def template_file_id(self) -> pulumi.Input[str]:
        """
        The identifier for an OS template file.
        """
        return pulumi.get(self, "template_file_id")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type (defaults to `unmanaged`).
        """
        return pulumi.get(self, "type")

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


