# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities

__all__ = [
    'FirewallDeviceArgs',
    'FirewallInboundArgs',
    'FirewallOutboundArgs',
    'InstanceAlertsArgs',
    'InstanceBackupsArgs',
    'InstanceBackupsScheduleArgs',
    'InstanceConfigArgs',
    'InstanceConfigDevicesArgs',
    'InstanceConfigDevicesSdaArgs',
    'InstanceConfigDevicesSdbArgs',
    'InstanceConfigDevicesSdcArgs',
    'InstanceConfigDevicesSddArgs',
    'InstanceConfigDevicesSdeArgs',
    'InstanceConfigDevicesSdfArgs',
    'InstanceConfigDevicesSdgArgs',
    'InstanceConfigDevicesSdhArgs',
    'InstanceConfigHelpersArgs',
    'InstanceDiskArgs',
    'InstanceSpecsArgs',
    'LkeClusterPoolArgs',
    'LkeClusterPoolNodeArgs',
    'NodeBalancerConfigNodeStatusArgs',
    'NodeBalancerTransferArgs',
    'ObjectStorageBucketCertArgs',
    'ObjectStorageBucketLifecycleRuleArgs',
    'ObjectStorageBucketLifecycleRuleExpirationArgs',
    'ObjectStorageBucketLifecycleRuleNoncurrentVersionExpirationArgs',
    'ObjectStorageKeyBucketAccessArgs',
    'StackScriptUserDefinedFieldArgs',
    'UserDomainGrantArgs',
    'UserGlobalGrantsArgs',
    'UserImageGrantArgs',
    'UserLinodeGrantArgs',
    'UserLongviewGrantArgs',
    'UserNodebalancerGrantArgs',
    'UserStackscriptGrantArgs',
    'UserVolumeGrantArgs',
    'VlanAttachedLinodeArgs',
    'GetImagesFilterArgs',
    'GetInstancesFilterArgs',
    'GetStackScriptUserDefinedFieldArgs',
]

@pulumi.input_type
class FirewallDeviceArgs:
    def __init__(__self__, *,
                 entity_id: Optional[pulumi.Input[int]] = None,
                 id: Optional[pulumi.Input[int]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 url: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] entity_id: The ID of the underlying entity this device references (i.e. the Linode's ID).
        :param pulumi.Input[int] id: The ID of the Firewall Device.
        :param pulumi.Input[str] label: Used to identify this rule. For display purposes only.
        :param pulumi.Input[str] type: The type of Firewall Device.
        """
        if entity_id is not None:
            pulumi.set(__self__, "entity_id", entity_id)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter(name="entityId")
    def entity_id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the underlying entity this device references (i.e. the Linode's ID).
        """
        return pulumi.get(self, "entity_id")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the Firewall Device.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Used to identify this rule. For display purposes only.
        """
        return pulumi.get(self, "label")

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

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

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

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

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


@pulumi.input_type
class FirewallInboundArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 label: pulumi.Input[str],
                 protocol: pulumi.Input[str],
                 ipv4s: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ipv6s: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ports: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] action: Controls whether traffic is accepted or dropped by this rule. Overrides the Firewall’s inbound_policy if this is an inbound rule, or the outbound_policy if this is an outbound rule.
        :param pulumi.Input[str] label: Used to identify this rule. For display purposes only.
        :param pulumi.Input[str] protocol: The network protocol this rule controls.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ipv4s: A list of IPv4 addresses or networks. Must be in IP/mask format.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ipv6s: A list of IPv6 addresses or networks. Must be in IP/mask format.
        :param pulumi.Input[str] ports: A string representation of ports and/or port ranges (i.e. "443" or "80-90, 91").
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "protocol", protocol)
        if ipv4s is not None:
            pulumi.set(__self__, "ipv4s", ipv4s)
        if ipv6s is not None:
            pulumi.set(__self__, "ipv6s", ipv6s)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[str]:
        """
        Controls whether traffic is accepted or dropped by this rule. Overrides the Firewall’s inbound_policy if this is an inbound rule, or the outbound_policy if this is an outbound rule.
        """
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter
    def label(self) -> pulumi.Input[str]:
        """
        Used to identify this rule. For display purposes only.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def protocol(self) -> pulumi.Input[str]:
        """
        The network protocol this rule controls.
        """
        return pulumi.get(self, "protocol")

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

    @property
    @pulumi.getter
    def ipv4s(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of IPv4 addresses or networks. Must be in IP/mask format.
        """
        return pulumi.get(self, "ipv4s")

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

    @property
    @pulumi.getter
    def ipv6s(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of IPv6 addresses or networks. Must be in IP/mask format.
        """
        return pulumi.get(self, "ipv6s")

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

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[str]]:
        """
        A string representation of ports and/or port ranges (i.e. "443" or "80-90, 91").
        """
        return pulumi.get(self, "ports")

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


@pulumi.input_type
class FirewallOutboundArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 label: pulumi.Input[str],
                 protocol: pulumi.Input[str],
                 ipv4s: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ipv6s: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ports: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] action: Controls whether traffic is accepted or dropped by this rule. Overrides the Firewall’s inbound_policy if this is an inbound rule, or the outbound_policy if this is an outbound rule.
        :param pulumi.Input[str] label: Used to identify this rule. For display purposes only.
        :param pulumi.Input[str] protocol: The network protocol this rule controls.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ipv4s: A list of IPv4 addresses or networks. Must be in IP/mask format.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ipv6s: A list of IPv6 addresses or networks. Must be in IP/mask format.
        :param pulumi.Input[str] ports: A string representation of ports and/or port ranges (i.e. "443" or "80-90, 91").
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "protocol", protocol)
        if ipv4s is not None:
            pulumi.set(__self__, "ipv4s", ipv4s)
        if ipv6s is not None:
            pulumi.set(__self__, "ipv6s", ipv6s)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[str]:
        """
        Controls whether traffic is accepted or dropped by this rule. Overrides the Firewall’s inbound_policy if this is an inbound rule, or the outbound_policy if this is an outbound rule.
        """
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter
    def label(self) -> pulumi.Input[str]:
        """
        Used to identify this rule. For display purposes only.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def protocol(self) -> pulumi.Input[str]:
        """
        The network protocol this rule controls.
        """
        return pulumi.get(self, "protocol")

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

    @property
    @pulumi.getter
    def ipv4s(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of IPv4 addresses or networks. Must be in IP/mask format.
        """
        return pulumi.get(self, "ipv4s")

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

    @property
    @pulumi.getter
    def ipv6s(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of IPv6 addresses or networks. Must be in IP/mask format.
        """
        return pulumi.get(self, "ipv6s")

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

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[str]]:
        """
        A string representation of ports and/or port ranges (i.e. "443" or "80-90, 91").
        """
        return pulumi.get(self, "ports")

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


@pulumi.input_type
class InstanceAlertsArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[int]] = None,
                 io: Optional[pulumi.Input[int]] = None,
                 network_in: Optional[pulumi.Input[int]] = None,
                 network_out: Optional[pulumi.Input[int]] = None,
                 transfer_quota: Optional[pulumi.Input[int]] = None):
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if io is not None:
            pulumi.set(__self__, "io", io)
        if network_in is not None:
            pulumi.set(__self__, "network_in", network_in)
        if network_out is not None:
            pulumi.set(__self__, "network_out", network_out)
        if transfer_quota is not None:
            pulumi.set(__self__, "transfer_quota", transfer_quota)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class InstanceBackupsArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 schedule: Optional[pulumi.Input['InstanceBackupsScheduleArgs']] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if schedule is not None:
            pulumi.set(__self__, "schedule", schedule)

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

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

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

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


@pulumi.input_type
class InstanceBackupsScheduleArgs:
    def __init__(__self__, *,
                 day: Optional[pulumi.Input[str]] = None,
                 window: Optional[pulumi.Input[str]] = None):
        if day is not None:
            pulumi.set(__self__, "day", day)
        if window is not None:
            pulumi.set(__self__, "window", window)

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

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

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

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


@pulumi.input_type
class InstanceConfigArgs:
    def __init__(__self__, *,
                 label: pulumi.Input[str],
                 comments: Optional[pulumi.Input[str]] = None,
                 devices: Optional[pulumi.Input['InstanceConfigDevicesArgs']] = None,
                 helpers: Optional[pulumi.Input['InstanceConfigHelpersArgs']] = None,
                 kernel: Optional[pulumi.Input[str]] = None,
                 memory_limit: Optional[pulumi.Input[int]] = None,
                 root_device: Optional[pulumi.Input[str]] = None,
                 run_level: Optional[pulumi.Input[str]] = None,
                 virt_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: The Config's label for display purposes.  Also used by `boot_config_label`.
        :param pulumi.Input[str] comments: - Arbitrary user comments about this `config`.
        :param pulumi.Input['InstanceConfigDevicesArgs'] devices: A list of `disk` or `volume` attachments for this `config`.  If the `boot_config_label` omits a `devices` block, the Linode will not be booted.
        :param pulumi.Input['InstanceConfigHelpersArgs'] helpers: Helpers enabled when booting to this Linode Config.
        :param pulumi.Input[str] kernel: - A Kernel ID to boot a Linode with. Default is based on image choice. Examples are `linode/latest-64bit`, `linode/grub2`, `linode/direct-disk`, etc. See all kernels [here](https://api.linode.com/v4/linode/kernels). Note that this is a paginated API endpoint ([docs](https://developers.linode.com/api/v4/linode-kernels)).
        :param pulumi.Input[int] memory_limit: - Defaults to the total RAM of the Linode
        :param pulumi.Input[str] root_device: - The root device to boot. The corresponding disk must be attached to a `device` slot.  Example: `"/dev/sda"`
        :param pulumi.Input[str] run_level: - Defines the state of your Linode after booting. Defaults to `"default"`.
        :param pulumi.Input[str] virt_mode: - Controls the virtualization mode. Defaults to `"paravirt"`.
        """
        pulumi.set(__self__, "label", label)
        if comments is not None:
            pulumi.set(__self__, "comments", comments)
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if helpers is not None:
            pulumi.set(__self__, "helpers", helpers)
        if kernel is not None:
            pulumi.set(__self__, "kernel", kernel)
        if memory_limit is not None:
            pulumi.set(__self__, "memory_limit", memory_limit)
        if root_device is not None:
            pulumi.set(__self__, "root_device", root_device)
        if run_level is not None:
            pulumi.set(__self__, "run_level", run_level)
        if virt_mode is not None:
            pulumi.set(__self__, "virt_mode", virt_mode)

    @property
    @pulumi.getter
    def label(self) -> pulumi.Input[str]:
        """
        The Config's label for display purposes.  Also used by `boot_config_label`.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def comments(self) -> Optional[pulumi.Input[str]]:
        """
        - Arbitrary user comments about this `config`.
        """
        return pulumi.get(self, "comments")

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

    @property
    @pulumi.getter
    def devices(self) -> Optional[pulumi.Input['InstanceConfigDevicesArgs']]:
        """
        A list of `disk` or `volume` attachments for this `config`.  If the `boot_config_label` omits a `devices` block, the Linode will not be booted.
        """
        return pulumi.get(self, "devices")

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

    @property
    @pulumi.getter
    def helpers(self) -> Optional[pulumi.Input['InstanceConfigHelpersArgs']]:
        """
        Helpers enabled when booting to this Linode Config.
        """
        return pulumi.get(self, "helpers")

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

    @property
    @pulumi.getter
    def kernel(self) -> Optional[pulumi.Input[str]]:
        """
        - A Kernel ID to boot a Linode with. Default is based on image choice. Examples are `linode/latest-64bit`, `linode/grub2`, `linode/direct-disk`, etc. See all kernels [here](https://api.linode.com/v4/linode/kernels). Note that this is a paginated API endpoint ([docs](https://developers.linode.com/api/v4/linode-kernels)).
        """
        return pulumi.get(self, "kernel")

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

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[pulumi.Input[int]]:
        """
        - Defaults to the total RAM of the Linode
        """
        return pulumi.get(self, "memory_limit")

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

    @property
    @pulumi.getter(name="rootDevice")
    def root_device(self) -> Optional[pulumi.Input[str]]:
        """
        - The root device to boot. The corresponding disk must be attached to a `device` slot.  Example: `"/dev/sda"`
        """
        return pulumi.get(self, "root_device")

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

    @property
    @pulumi.getter(name="runLevel")
    def run_level(self) -> Optional[pulumi.Input[str]]:
        """
        - Defines the state of your Linode after booting. Defaults to `"default"`.
        """
        return pulumi.get(self, "run_level")

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

    @property
    @pulumi.getter(name="virtMode")
    def virt_mode(self) -> Optional[pulumi.Input[str]]:
        """
        - Controls the virtualization mode. Defaults to `"paravirt"`.
        """
        return pulumi.get(self, "virt_mode")

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


@pulumi.input_type
class InstanceConfigDevicesArgs:
    def __init__(__self__, *,
                 sda: Optional[pulumi.Input['InstanceConfigDevicesSdaArgs']] = None,
                 sdb: Optional[pulumi.Input['InstanceConfigDevicesSdbArgs']] = None,
                 sdc: Optional[pulumi.Input['InstanceConfigDevicesSdcArgs']] = None,
                 sdd: Optional[pulumi.Input['InstanceConfigDevicesSddArgs']] = None,
                 sde: Optional[pulumi.Input['InstanceConfigDevicesSdeArgs']] = None,
                 sdf: Optional[pulumi.Input['InstanceConfigDevicesSdfArgs']] = None,
                 sdg: Optional[pulumi.Input['InstanceConfigDevicesSdgArgs']] = None,
                 sdh: Optional[pulumi.Input['InstanceConfigDevicesSdhArgs']] = None):
        """
        :param pulumi.Input['InstanceConfigDevicesSdaArgs'] sda: ... `sdh` - (Optional) The SDA-SDH slots, represent the Linux block device nodes for the first 8 disks attached to the Linode.  Each device must be suplied sequentially.  The device can be either a Disk or a Volume identified by `disk_label` or `volume_id`. Only one disk identifier is permitted per slot. Devices mapped from `sde` through `sdh` are unavailable in `"fullvirt"` `virt_mode`.
        """
        if sda is not None:
            pulumi.set(__self__, "sda", sda)
        if sdb is not None:
            pulumi.set(__self__, "sdb", sdb)
        if sdc is not None:
            pulumi.set(__self__, "sdc", sdc)
        if sdd is not None:
            pulumi.set(__self__, "sdd", sdd)
        if sde is not None:
            pulumi.set(__self__, "sde", sde)
        if sdf is not None:
            pulumi.set(__self__, "sdf", sdf)
        if sdg is not None:
            pulumi.set(__self__, "sdg", sdg)
        if sdh is not None:
            pulumi.set(__self__, "sdh", sdh)

    @property
    @pulumi.getter
    def sda(self) -> Optional[pulumi.Input['InstanceConfigDevicesSdaArgs']]:
        """
        ... `sdh` - (Optional) The SDA-SDH slots, represent the Linux block device nodes for the first 8 disks attached to the Linode.  Each device must be suplied sequentially.  The device can be either a Disk or a Volume identified by `disk_label` or `volume_id`. Only one disk identifier is permitted per slot. Devices mapped from `sde` through `sdh` are unavailable in `"fullvirt"` `virt_mode`.
        """
        return pulumi.get(self, "sda")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class InstanceConfigDevicesSdaArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigDevicesSdbArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigDevicesSdcArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigDevicesSddArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigDevicesSdeArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigDevicesSdfArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigDevicesSdgArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigDevicesSdhArgs:
    def __init__(__self__, *,
                 disk_id: Optional[pulumi.Input[int]] = None,
                 disk_label: Optional[pulumi.Input[str]] = None,
                 volume_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] disk_id: The Disk ID of the associated `disk_label`, if used.
        :param pulumi.Input[str] disk_label: The `label` of the `disk` to map to this `device` slot.
        :param pulumi.Input[int] volume_id: The Volume ID to map to this `device` slot.
        """
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if disk_label is not None:
            pulumi.set(__self__, "disk_label", disk_label)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Disk ID of the associated `disk_label`, if used.
        """
        return pulumi.get(self, "disk_id")

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

    @property
    @pulumi.getter(name="diskLabel")
    def disk_label(self) -> Optional[pulumi.Input[str]]:
        """
        The `label` of the `disk` to map to this `device` slot.
        """
        return pulumi.get(self, "disk_label")

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

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[pulumi.Input[int]]:
        """
        The Volume ID to map to this `device` slot.
        """
        return pulumi.get(self, "volume_id")

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


@pulumi.input_type
class InstanceConfigHelpersArgs:
    def __init__(__self__, *,
                 devtmpfs_automount: Optional[pulumi.Input[bool]] = None,
                 distro: Optional[pulumi.Input[bool]] = None,
                 modules_dep: Optional[pulumi.Input[bool]] = None,
                 network: Optional[pulumi.Input[bool]] = None,
                 updatedb_disabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] distro: Controls the behavior of the Linode Config's Distribution Helper setting.
        :param pulumi.Input[bool] modules_dep: Creates a modules dependency file for the Kernel you run.
        :param pulumi.Input[bool] network: Controls the behavior of the Linode Config's Network Helper setting, used to automatically configure additional IP addresses assigned to this instance.
        :param pulumi.Input[bool] updatedb_disabled: Disables updatedb cron job to avoid disk thrashing.
        """
        if devtmpfs_automount is not None:
            pulumi.set(__self__, "devtmpfs_automount", devtmpfs_automount)
        if distro is not None:
            pulumi.set(__self__, "distro", distro)
        if modules_dep is not None:
            pulumi.set(__self__, "modules_dep", modules_dep)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if updatedb_disabled is not None:
            pulumi.set(__self__, "updatedb_disabled", updatedb_disabled)

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

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

    @property
    @pulumi.getter
    def distro(self) -> Optional[pulumi.Input[bool]]:
        """
        Controls the behavior of the Linode Config's Distribution Helper setting.
        """
        return pulumi.get(self, "distro")

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

    @property
    @pulumi.getter(name="modulesDep")
    def modules_dep(self) -> Optional[pulumi.Input[bool]]:
        """
        Creates a modules dependency file for the Kernel you run.
        """
        return pulumi.get(self, "modules_dep")

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

    @property
    @pulumi.getter
    def network(self) -> Optional[pulumi.Input[bool]]:
        """
        Controls the behavior of the Linode Config's Network Helper setting, used to automatically configure additional IP addresses assigned to this instance.
        """
        return pulumi.get(self, "network")

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

    @property
    @pulumi.getter(name="updatedbDisabled")
    def updatedb_disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Disables updatedb cron job to avoid disk thrashing.
        """
        return pulumi.get(self, "updatedb_disabled")

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


@pulumi.input_type
class InstanceDiskArgs:
    def __init__(__self__, *,
                 label: pulumi.Input[str],
                 size: pulumi.Input[int],
                 authorized_keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 authorized_users: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 filesystem: Optional[pulumi.Input[str]] = None,
                 id: Optional[pulumi.Input[int]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 read_only: Optional[pulumi.Input[bool]] = None,
                 root_pass: Optional[pulumi.Input[str]] = None,
                 stackscript_data: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 stackscript_id: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] label: The Config's label for display purposes.  Also used by `boot_config_label`.
        :param pulumi.Input[int] size: The size of the Disk in MB.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] authorized_keys: A list of SSH public keys to deploy for the root user on the newly created Linode. Only accepted if `image` is provided. *This value can not be imported.* *Changing `authorized_keys` forces the creation of a new Linode Instance.*
        :param pulumi.Input[Sequence[pulumi.Input[str]]] authorized_users: A list of Linode usernames. If the usernames have associated SSH keys, the keys will be appended to the `root` user's `~/.ssh/authorized_keys` file automatically. *This value can not be imported.* *Changing `authorized_users` forces the creation of a new Linode Instance.*
        :param pulumi.Input[str] filesystem: The Disk filesystem can be one of: `"raw"`, `"swap"`, `"ext3"`, `"ext4"`, or `"initrd"` which has a max size of 32mb and can be used in the config `initrd` (not currently supported in this provider).
        :param pulumi.Input[int] id: The ID of the disk in the Linode API.
        :param pulumi.Input[str] image: An Image ID to deploy the Disk from. Official Linode Images start with linode/, while your Images start with private/. See /images for more information on the Images available for you to use. Examples are `linode/debian9`, `linode/fedora28`, `linode/ubuntu16.04lts`, `linode/arch`, and `private/12345`. See all images [here](https://api.linode.com/v4/linode/kernels). *Changing `image` forces the creation of a new Linode Instance.*
        :param pulumi.Input[str] root_pass: The initial password for the `root` user account. *This value can not be imported.* *Changing `root_pass` forces the creation of a new Linode Instance.* *If omitted, a random password will be generated but will not be stored in state.*
        :param pulumi.Input[Mapping[str, Any]] stackscript_data: An object containing responses to any User Defined Fields present in the StackScript being deployed to this Linode. Only accepted if 'stackscript_id' is given. The required values depend on the StackScript being deployed.  *This value can not be imported.* *Changing `stackscript_data` forces the creation of a new Linode Instance.*
        :param pulumi.Input[int] stackscript_id: The StackScript to deploy to the newly created Linode. If provided, 'image' must also be provided, and must be an Image that is compatible with this StackScript. *This value can not be imported.* *Changing `stackscript_id` forces the creation of a new Linode Instance.*
        """
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "size", size)
        if authorized_keys is not None:
            pulumi.set(__self__, "authorized_keys", authorized_keys)
        if authorized_users is not None:
            pulumi.set(__self__, "authorized_users", authorized_users)
        if filesystem is not None:
            pulumi.set(__self__, "filesystem", filesystem)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)
        if root_pass is not None:
            pulumi.set(__self__, "root_pass", root_pass)
        if stackscript_data is not None:
            pulumi.set(__self__, "stackscript_data", stackscript_data)
        if stackscript_id is not None:
            pulumi.set(__self__, "stackscript_id", stackscript_id)

    @property
    @pulumi.getter
    def label(self) -> pulumi.Input[str]:
        """
        The Config's label for display purposes.  Also used by `boot_config_label`.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def size(self) -> pulumi.Input[int]:
        """
        The size of the Disk in MB.
        """
        return pulumi.get(self, "size")

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

    @property
    @pulumi.getter(name="authorizedKeys")
    def authorized_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of SSH public keys to deploy for the root user on the newly created Linode. Only accepted if `image` is provided. *This value can not be imported.* *Changing `authorized_keys` forces the creation of a new Linode Instance.*
        """
        return pulumi.get(self, "authorized_keys")

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

    @property
    @pulumi.getter(name="authorizedUsers")
    def authorized_users(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of Linode usernames. If the usernames have associated SSH keys, the keys will be appended to the `root` user's `~/.ssh/authorized_keys` file automatically. *This value can not be imported.* *Changing `authorized_users` forces the creation of a new Linode Instance.*
        """
        return pulumi.get(self, "authorized_users")

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

    @property
    @pulumi.getter
    def filesystem(self) -> Optional[pulumi.Input[str]]:
        """
        The Disk filesystem can be one of: `"raw"`, `"swap"`, `"ext3"`, `"ext4"`, or `"initrd"` which has a max size of 32mb and can be used in the config `initrd` (not currently supported in this provider).
        """
        return pulumi.get(self, "filesystem")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the disk in the Linode API.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        An Image ID to deploy the Disk from. Official Linode Images start with linode/, while your Images start with private/. See /images for more information on the Images available for you to use. Examples are `linode/debian9`, `linode/fedora28`, `linode/ubuntu16.04lts`, `linode/arch`, and `private/12345`. See all images [here](https://api.linode.com/v4/linode/kernels). *Changing `image` forces the creation of a new Linode Instance.*
        """
        return pulumi.get(self, "image")

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

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[pulumi.Input[bool]]:
        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(name="rootPass")
    def root_pass(self) -> Optional[pulumi.Input[str]]:
        """
        The initial password for the `root` user account. *This value can not be imported.* *Changing `root_pass` forces the creation of a new Linode Instance.* *If omitted, a random password will be generated but will not be stored in state.*
        """
        return pulumi.get(self, "root_pass")

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

    @property
    @pulumi.getter(name="stackscriptData")
    def stackscript_data(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        An object containing responses to any User Defined Fields present in the StackScript being deployed to this Linode. Only accepted if 'stackscript_id' is given. The required values depend on the StackScript being deployed.  *This value can not be imported.* *Changing `stackscript_data` forces the creation of a new Linode Instance.*
        """
        return pulumi.get(self, "stackscript_data")

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

    @property
    @pulumi.getter(name="stackscriptId")
    def stackscript_id(self) -> Optional[pulumi.Input[int]]:
        """
        The StackScript to deploy to the newly created Linode. If provided, 'image' must also be provided, and must be an Image that is compatible with this StackScript. *This value can not be imported.* *Changing `stackscript_id` forces the creation of a new Linode Instance.*
        """
        return pulumi.get(self, "stackscript_id")

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


@pulumi.input_type
class InstanceSpecsArgs:
    def __init__(__self__, *,
                 disk: Optional[pulumi.Input[int]] = None,
                 memory: Optional[pulumi.Input[int]] = None,
                 transfer: Optional[pulumi.Input[int]] = None,
                 vcpus: Optional[pulumi.Input[int]] = None):
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if transfer is not None:
            pulumi.set(__self__, "transfer", transfer)
        if vcpus is not None:
            pulumi.set(__self__, "vcpus", vcpus)

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

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

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

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

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

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

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

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


@pulumi.input_type
class LkeClusterPoolArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 type: pulumi.Input[str],
                 id: Optional[pulumi.Input[int]] = None,
                 nodes: Optional[pulumi.Input[Sequence[pulumi.Input['LkeClusterPoolNodeArgs']]]] = None):
        """
        :param pulumi.Input[int] count: The number of nodes in the Node Pool.
        :param pulumi.Input[str] type: A Linode Type for all of the nodes in the Node Pool.
        :param pulumi.Input[int] id: The ID of the node.
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "type", type)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if nodes is not None:
            pulumi.set(__self__, "nodes", nodes)

    @property
    @pulumi.getter
    def count(self) -> pulumi.Input[int]:
        """
        The number of nodes in the Node Pool.
        """
        return pulumi.get(self, "count")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        A Linode Type for all of the nodes in the Node Pool.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the node.
        """
        return pulumi.get(self, "id")

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

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

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


@pulumi.input_type
class LkeClusterPoolNodeArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[str]] = None,
                 instance_id: Optional[pulumi.Input[int]] = None,
                 status: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of the node.
        :param pulumi.Input[int] instance_id: The ID of the underlying Linode instance.
        :param pulumi.Input[str] status: The status of the node.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the node.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the underlying Linode instance.
        """
        return pulumi.get(self, "instance_id")

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

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

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


@pulumi.input_type
class NodeBalancerConfigNodeStatusArgs:
    def __init__(__self__, *,
                 down: Optional[pulumi.Input[int]] = None,
                 up: Optional[pulumi.Input[int]] = None):
        if down is not None:
            pulumi.set(__self__, "down", down)
        if up is not None:
            pulumi.set(__self__, "up", up)

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

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

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

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


@pulumi.input_type
class NodeBalancerTransferArgs:
    def __init__(__self__, *,
                 in_: Optional[pulumi.Input[float]] = None,
                 out: Optional[pulumi.Input[float]] = None,
                 total: Optional[pulumi.Input[float]] = None):
        if in_ is not None:
            pulumi.set(__self__, "in_", in_)
        if out is not None:
            pulumi.set(__self__, "out", out)
        if total is not None:
            pulumi.set(__self__, "total", total)

    @property
    @pulumi.getter(name="in")
    def in_(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "in_")

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

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

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

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

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


@pulumi.input_type
class ObjectStorageBucketCertArgs:
    def __init__(__self__, *,
                 certificate: pulumi.Input[str],
                 private_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate: The Base64 encoded and PEM formatted SSL certificate.
        :param pulumi.Input[str] private_key: The private key associated with the TLS/SSL certificate.
        """
        pulumi.set(__self__, "certificate", certificate)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter
    def certificate(self) -> pulumi.Input[str]:
        """
        The Base64 encoded and PEM formatted SSL certificate.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> pulumi.Input[str]:
        """
        The private key associated with the TLS/SSL certificate.
        """
        return pulumi.get(self, "private_key")

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


@pulumi.input_type
class ObjectStorageBucketLifecycleRuleArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 abort_incomplete_multipart_upload_days: Optional[pulumi.Input[int]] = None,
                 expiration: Optional[pulumi.Input['ObjectStorageBucketLifecycleRuleExpirationArgs']] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 noncurrent_version_expiration: Optional[pulumi.Input['ObjectStorageBucketLifecycleRuleNoncurrentVersionExpirationArgs']] = None,
                 prefix: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enabled: Specifies whether the lifecycle rule is active.
        :param pulumi.Input[int] abort_incomplete_multipart_upload_days: Specifies the number of days after initiating a multipart upload when the multipart upload must be completed.
        :param pulumi.Input[str] id: The unique identifier for the rule.
        :param pulumi.Input[str] prefix: The object key prefix identifying one or more objects to which the rule applies.
        """
        pulumi.set(__self__, "enabled", enabled)
        if abort_incomplete_multipart_upload_days is not None:
            pulumi.set(__self__, "abort_incomplete_multipart_upload_days", abort_incomplete_multipart_upload_days)
        if expiration is not None:
            pulumi.set(__self__, "expiration", expiration)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if noncurrent_version_expiration is not None:
            pulumi.set(__self__, "noncurrent_version_expiration", noncurrent_version_expiration)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Specifies whether the lifecycle rule is active.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="abortIncompleteMultipartUploadDays")
    def abort_incomplete_multipart_upload_days(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the number of days after initiating a multipart upload when the multipart upload must be completed.
        """
        return pulumi.get(self, "abort_incomplete_multipart_upload_days")

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

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

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The unique identifier for the rule.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="noncurrentVersionExpiration")
    def noncurrent_version_expiration(self) -> Optional[pulumi.Input['ObjectStorageBucketLifecycleRuleNoncurrentVersionExpirationArgs']]:
        return pulumi.get(self, "noncurrent_version_expiration")

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

    @property
    @pulumi.getter
    def prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The object key prefix identifying one or more objects to which the rule applies.
        """
        return pulumi.get(self, "prefix")

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


@pulumi.input_type
class ObjectStorageBucketLifecycleRuleExpirationArgs:
    def __init__(__self__, *,
                 date: Optional[pulumi.Input[str]] = None,
                 days: Optional[pulumi.Input[int]] = None,
                 expired_object_delete_marker: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] date: Specifies the date after which you want the corresponding action to take effect.
        :param pulumi.Input[int] days: Specifies the number of days non-current object versions expire.
        :param pulumi.Input[bool] expired_object_delete_marker: On a versioned bucket (versioning-enabled or versioning-suspended bucket), you can add this element in the lifecycle configuration to direct Linode Object Storage to delete expired object delete markers. This cannot be specified with Days or Date in a Lifecycle Expiration Policy.
        """
        if date is not None:
            pulumi.set(__self__, "date", date)
        if days is not None:
            pulumi.set(__self__, "days", days)
        if expired_object_delete_marker is not None:
            pulumi.set(__self__, "expired_object_delete_marker", expired_object_delete_marker)

    @property
    @pulumi.getter
    def date(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the date after which you want the corresponding action to take effect.
        """
        return pulumi.get(self, "date")

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

    @property
    @pulumi.getter
    def days(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the number of days non-current object versions expire.
        """
        return pulumi.get(self, "days")

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

    @property
    @pulumi.getter(name="expiredObjectDeleteMarker")
    def expired_object_delete_marker(self) -> Optional[pulumi.Input[bool]]:
        """
        On a versioned bucket (versioning-enabled or versioning-suspended bucket), you can add this element in the lifecycle configuration to direct Linode Object Storage to delete expired object delete markers. This cannot be specified with Days or Date in a Lifecycle Expiration Policy.
        """
        return pulumi.get(self, "expired_object_delete_marker")

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


@pulumi.input_type
class ObjectStorageBucketLifecycleRuleNoncurrentVersionExpirationArgs:
    def __init__(__self__, *,
                 days: pulumi.Input[int]):
        """
        :param pulumi.Input[int] days: Specifies the number of days non-current object versions expire.
        """
        pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter
    def days(self) -> pulumi.Input[int]:
        """
        Specifies the number of days non-current object versions expire.
        """
        return pulumi.get(self, "days")

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


@pulumi.input_type
class ObjectStorageKeyBucketAccessArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 cluster: pulumi.Input[str],
                 permissions: pulumi.Input[str]):
        """
        :param pulumi.Input[str] bucket_name: The unique label of the bucket to which the key will grant limited access.
        :param pulumi.Input[str] cluster: The Object Storage cluster where a bucket to which the key is granting access is hosted.
        :param pulumi.Input[str] permissions: This Limited Access Key’s permissions for the selected bucket. Can be one of `"read_write"` or `"read_only"`. *Changing `permissions` forces the creation of a new Object Storage Key.*.
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "cluster", cluster)
        pulumi.set(__self__, "permissions", permissions)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> pulumi.Input[str]:
        """
        The unique label of the bucket to which the key will grant limited access.
        """
        return pulumi.get(self, "bucket_name")

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

    @property
    @pulumi.getter
    def cluster(self) -> pulumi.Input[str]:
        """
        The Object Storage cluster where a bucket to which the key is granting access is hosted.
        """
        return pulumi.get(self, "cluster")

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

    @property
    @pulumi.getter
    def permissions(self) -> pulumi.Input[str]:
        """
        This Limited Access Key’s permissions for the selected bucket. Can be one of `"read_write"` or `"read_only"`. *Changing `permissions` forces the creation of a new Object Storage Key.*.
        """
        return pulumi.get(self, "permissions")

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


@pulumi.input_type
class StackScriptUserDefinedFieldArgs:
    def __init__(__self__, *,
                 default: Optional[pulumi.Input[str]] = None,
                 example: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 many_of: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 one_of: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: The StackScript's label is for display purposes only.
        """
        if default is not None:
            pulumi.set(__self__, "default", default)
        if example is not None:
            pulumi.set(__self__, "example", example)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if many_of is not None:
            pulumi.set(__self__, "many_of", many_of)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if one_of is not None:
            pulumi.set(__self__, "one_of", one_of)

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

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

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

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        The StackScript's label is for display purposes only.
        """
        return pulumi.get(self, "label")

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

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

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

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

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

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

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


@pulumi.input_type
class UserDomainGrantArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[int],
                 permissions: pulumi.Input[str]):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permissions", permissions)

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

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

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

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


@pulumi.input_type
class UserGlobalGrantsArgs:
    def __init__(__self__, *,
                 account_access: Optional[pulumi.Input[str]] = None,
                 add_domains: Optional[pulumi.Input[bool]] = None,
                 add_images: Optional[pulumi.Input[bool]] = None,
                 add_linodes: Optional[pulumi.Input[bool]] = None,
                 add_longview: Optional[pulumi.Input[bool]] = None,
                 add_nodebalancers: Optional[pulumi.Input[bool]] = None,
                 add_stackscripts: Optional[pulumi.Input[bool]] = None,
                 add_volumes: Optional[pulumi.Input[bool]] = None,
                 cancel_account: Optional[pulumi.Input[bool]] = None,
                 longview_subscription: Optional[pulumi.Input[bool]] = None):
        if account_access is not None:
            pulumi.set(__self__, "account_access", account_access)
        if add_domains is not None:
            pulumi.set(__self__, "add_domains", add_domains)
        if add_images is not None:
            pulumi.set(__self__, "add_images", add_images)
        if add_linodes is not None:
            pulumi.set(__self__, "add_linodes", add_linodes)
        if add_longview is not None:
            pulumi.set(__self__, "add_longview", add_longview)
        if add_nodebalancers is not None:
            pulumi.set(__self__, "add_nodebalancers", add_nodebalancers)
        if add_stackscripts is not None:
            pulumi.set(__self__, "add_stackscripts", add_stackscripts)
        if add_volumes is not None:
            pulumi.set(__self__, "add_volumes", add_volumes)
        if cancel_account is not None:
            pulumi.set(__self__, "cancel_account", cancel_account)
        if longview_subscription is not None:
            pulumi.set(__self__, "longview_subscription", longview_subscription)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class UserImageGrantArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[int],
                 permissions: pulumi.Input[str]):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permissions", permissions)

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

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

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

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


@pulumi.input_type
class UserLinodeGrantArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[int],
                 permissions: pulumi.Input[str]):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permissions", permissions)

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

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

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

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


@pulumi.input_type
class UserLongviewGrantArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[int],
                 permissions: pulumi.Input[str]):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permissions", permissions)

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

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

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

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


@pulumi.input_type
class UserNodebalancerGrantArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[int],
                 permissions: pulumi.Input[str]):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permissions", permissions)

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

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

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

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


@pulumi.input_type
class UserStackscriptGrantArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[int],
                 permissions: pulumi.Input[str]):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permissions", permissions)

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

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

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

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


@pulumi.input_type
class UserVolumeGrantArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[int],
                 permissions: pulumi.Input[str]):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "permissions", permissions)

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

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

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

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


@pulumi.input_type
class VlanAttachedLinodeArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[int]] = None,
                 ipv4_address: Optional[pulumi.Input[str]] = None,
                 mac_address: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] id: The ID of the Linode.
        :param pulumi.Input[str] ipv4_address: The IPv4 address of the Linode.
        :param pulumi.Input[str] mac_address: The mac address of the Linode.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ipv4_address is not None:
            pulumi.set(__self__, "ipv4_address", ipv4_address)
        if mac_address is not None:
            pulumi.set(__self__, "mac_address", mac_address)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[int]]:
        """
        The ID of the Linode.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="ipv4Address")
    def ipv4_address(self) -> Optional[pulumi.Input[str]]:
        """
        The IPv4 address of the Linode.
        """
        return pulumi.get(self, "ipv4_address")

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

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

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


@pulumi.input_type
class GetImagesFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
        :param Sequence[str] values: A list of values for the filter to allow. These values should all be in string form.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values for the filter to allow. These values should all be in string form.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class GetInstancesFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: The name of the field to filter by. See the Filterable Fields section for a list of filterable fields.
        :param Sequence[str] values: A list of values for the filter to allow. These values should all be in string form.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the field to filter by. See the Filterable Fields section for a list of filterable fields.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values for the filter to allow. These values should all be in string form.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class GetStackScriptUserDefinedFieldArgs:
    def __init__(__self__, *,
                 default: str,
                 example: str,
                 label: str,
                 many_of: str,
                 name: str,
                 one_of: str):
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "example", example)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "many_of", many_of)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "one_of", one_of)

    @property
    @pulumi.getter
    def default(self) -> str:
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: str):
        pulumi.set(self, "default", value)

    @property
    @pulumi.getter
    def example(self) -> str:
        return pulumi.get(self, "example")

    @example.setter
    def example(self, value: str):
        pulumi.set(self, "example", value)

    @property
    @pulumi.getter
    def label(self) -> str:
        return pulumi.get(self, "label")

    @label.setter
    def label(self, value: str):
        pulumi.set(self, "label", value)

    @property
    @pulumi.getter(name="manyOf")
    def many_of(self) -> str:
        return pulumi.get(self, "many_of")

    @many_of.setter
    def many_of(self, value: str):
        pulumi.set(self, "many_of", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="oneOf")
    def one_of(self) -> str:
        return pulumi.get(self, "one_of")

    @one_of.setter
    def one_of(self, value: str):
        pulumi.set(self, "one_of", value)


