# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = ['InstanceArgs', 'Instance']

@pulumi.input_type
class InstanceArgs:
    def __init__(__self__, *,
                 disk_image: pulumi.Input[str],
                 firewall_id: pulumi.Input[str],
                 hostname: Optional[pulumi.Input[str]] = None,
                 initial_user: Optional[pulumi.Input[str]] = None,
                 network_id: Optional[pulumi.Input[str]] = None,
                 notes: Optional[pulumi.Input[str]] = None,
                 private_ipv4: Optional[pulumi.Input[str]] = None,
                 public_ip_required: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 reserved_ipv4: Optional[pulumi.Input[str]] = None,
                 reverse_dns: Optional[pulumi.Input[str]] = None,
                 script: Optional[pulumi.Input[str]] = None,
                 size: Optional[pulumi.Input[str]] = None,
                 sshkey_id: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 write_password: Optional[pulumi.Input[bool]] = None):
        """
        The set of arguments for constructing a Instance resource.
        :param pulumi.Input[str] disk_image: The ID for the disk image to use to build the instance
        :param pulumi.Input[str] firewall_id: The ID of the firewall to use, from the current list. If left blank or not sent, the default firewall will be used (open
               to all)
        :param pulumi.Input[str] hostname: A fully qualified domain name that should be set as the instance's hostname
        :param pulumi.Input[str] initial_user: The name of the initial user created on the server (optional; this will default to the template's default_username and
               fallback to civo)
        :param pulumi.Input[str] network_id: This must be the ID of the network from the network listing (optional; default network used when not specified)
        :param pulumi.Input[str] notes: Add some notes to the instance
        :param pulumi.Input[str] private_ipv4: The private IPv4 address for the instance (optional)
        :param pulumi.Input[str] public_ip_required: This should be either 'none' or 'create' (default: 'create')
        :param pulumi.Input[str] region: The region for the instance, if not declare we use the region in declared in the provider
        :param pulumi.Input[str] reserved_ipv4: Can be either the UUID, name, or the IP address of the reserved IP
        :param pulumi.Input[str] reverse_dns: A fully qualified domain name that should be used as the instance's IP's reverse DNS (optional, uses the hostname if
               unspecified)
        :param pulumi.Input[str] script: The contents of a script that will be uploaded to /usr/local/bin/civo-user-init-script on your instance,
               read/write/executable only by root and then will be executed at the end of the cloud initialization
        :param pulumi.Input[str] size: The name of the size, from the current list, e.g. g3.xsmall
        :param pulumi.Input[str] sshkey_id: The ID of an already uploaded SSH public key to use for login to the default user (optional; if one isn't provided a
               random password will be set and returned in the initial_password field)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: An optional list of tags, represented as a key, value pair
        """
        pulumi.set(__self__, "disk_image", disk_image)
        pulumi.set(__self__, "firewall_id", firewall_id)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if initial_user is not None:
            pulumi.set(__self__, "initial_user", initial_user)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if notes is not None:
            pulumi.set(__self__, "notes", notes)
        if private_ipv4 is not None:
            pulumi.set(__self__, "private_ipv4", private_ipv4)
        if public_ip_required is not None:
            pulumi.set(__self__, "public_ip_required", public_ip_required)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if reserved_ipv4 is not None:
            pulumi.set(__self__, "reserved_ipv4", reserved_ipv4)
        if reverse_dns is not None:
            pulumi.set(__self__, "reverse_dns", reverse_dns)
        if script is not None:
            pulumi.set(__self__, "script", script)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if sshkey_id is not None:
            pulumi.set(__self__, "sshkey_id", sshkey_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if write_password is not None:
            pulumi.set(__self__, "write_password", write_password)

    @property
    @pulumi.getter(name="diskImage")
    def disk_image(self) -> pulumi.Input[str]:
        """
        The ID for the disk image to use to build the instance
        """
        return pulumi.get(self, "disk_image")

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

    @property
    @pulumi.getter(name="firewallId")
    def firewall_id(self) -> pulumi.Input[str]:
        """
        The ID of the firewall to use, from the current list. If left blank or not sent, the default firewall will be used (open
        to all)
        """
        return pulumi.get(self, "firewall_id")

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

    @property
    @pulumi.getter
    def hostname(self) -> Optional[pulumi.Input[str]]:
        """
        A fully qualified domain name that should be set as the instance's hostname
        """
        return pulumi.get(self, "hostname")

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

    @property
    @pulumi.getter(name="initialUser")
    def initial_user(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the initial user created on the server (optional; this will default to the template's default_username and
        fallback to civo)
        """
        return pulumi.get(self, "initial_user")

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

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[pulumi.Input[str]]:
        """
        This must be the ID of the network from the network listing (optional; default network used when not specified)
        """
        return pulumi.get(self, "network_id")

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

    @property
    @pulumi.getter
    def notes(self) -> Optional[pulumi.Input[str]]:
        """
        Add some notes to the instance
        """
        return pulumi.get(self, "notes")

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

    @property
    @pulumi.getter(name="privateIpv4")
    def private_ipv4(self) -> Optional[pulumi.Input[str]]:
        """
        The private IPv4 address for the instance (optional)
        """
        return pulumi.get(self, "private_ipv4")

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

    @property
    @pulumi.getter(name="publicIpRequired")
    def public_ip_required(self) -> Optional[pulumi.Input[str]]:
        """
        This should be either 'none' or 'create' (default: 'create')
        """
        return pulumi.get(self, "public_ip_required")

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

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        The region for the instance, if not declare we use the region in declared in the provider
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="reservedIpv4")
    def reserved_ipv4(self) -> Optional[pulumi.Input[str]]:
        """
        Can be either the UUID, name, or the IP address of the reserved IP
        """
        return pulumi.get(self, "reserved_ipv4")

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

    @property
    @pulumi.getter(name="reverseDns")
    def reverse_dns(self) -> Optional[pulumi.Input[str]]:
        """
        A fully qualified domain name that should be used as the instance's IP's reverse DNS (optional, uses the hostname if
        unspecified)
        """
        return pulumi.get(self, "reverse_dns")

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

    @property
    @pulumi.getter
    def script(self) -> Optional[pulumi.Input[str]]:
        """
        The contents of a script that will be uploaded to /usr/local/bin/civo-user-init-script on your instance,
        read/write/executable only by root and then will be executed at the end of the cloud initialization
        """
        return pulumi.get(self, "script")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the size, from the current list, e.g. g3.xsmall
        """
        return pulumi.get(self, "size")

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

    @property
    @pulumi.getter(name="sshkeyId")
    def sshkey_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of an already uploaded SSH public key to use for login to the default user (optional; if one isn't provided a
        random password will be set and returned in the initial_password field)
        """
        return pulumi.get(self, "sshkey_id")

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

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        An optional list of tags, represented as a key, value pair
        """
        return pulumi.get(self, "tags")

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

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

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


@pulumi.input_type
class _InstanceState:
    def __init__(__self__, *,
                 cpu_cores: Optional[pulumi.Input[int]] = None,
                 created_at: Optional[pulumi.Input[str]] = None,
                 disk_gb: Optional[pulumi.Input[int]] = None,
                 disk_image: Optional[pulumi.Input[str]] = None,
                 firewall_id: Optional[pulumi.Input[str]] = None,
                 hostname: Optional[pulumi.Input[str]] = None,
                 initial_password: Optional[pulumi.Input[str]] = None,
                 initial_user: Optional[pulumi.Input[str]] = None,
                 network_id: Optional[pulumi.Input[str]] = None,
                 notes: Optional[pulumi.Input[str]] = None,
                 private_ip: Optional[pulumi.Input[str]] = None,
                 private_ipv4: Optional[pulumi.Input[str]] = None,
                 public_ip: Optional[pulumi.Input[str]] = None,
                 public_ip_required: Optional[pulumi.Input[str]] = None,
                 ram_mb: Optional[pulumi.Input[int]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 reserved_ipv4: Optional[pulumi.Input[str]] = None,
                 reverse_dns: Optional[pulumi.Input[str]] = None,
                 script: Optional[pulumi.Input[str]] = None,
                 size: Optional[pulumi.Input[str]] = None,
                 source_id: Optional[pulumi.Input[str]] = None,
                 source_type: Optional[pulumi.Input[str]] = None,
                 sshkey_id: Optional[pulumi.Input[str]] = None,
                 status: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 write_password: Optional[pulumi.Input[bool]] = None):
        """
        Input properties used for looking up and filtering Instance resources.
        :param pulumi.Input[int] cpu_cores: (Number) Instance's CPU cores
        :param pulumi.Input[str] created_at: (String) Timestamp when the instance was created
        :param pulumi.Input[int] disk_gb: (Number) Instance's disk (GB)
        :param pulumi.Input[str] disk_image: The ID for the disk image to use to build the instance
        :param pulumi.Input[str] firewall_id: The ID of the firewall to use, from the current list. If left blank or not sent, the default firewall will be used (open
               to all)
        :param pulumi.Input[str] hostname: A fully qualified domain name that should be set as the instance's hostname
        :param pulumi.Input[str] initial_password: (String, Sensitive) Initial password for login
        :param pulumi.Input[str] initial_user: The name of the initial user created on the server (optional; this will default to the template's default_username and
               fallback to civo)
        :param pulumi.Input[str] network_id: This must be the ID of the network from the network listing (optional; default network used when not specified)
        :param pulumi.Input[str] notes: Add some notes to the instance
        :param pulumi.Input[str] private_ip: (String) Instance's private IP address
        :param pulumi.Input[str] private_ipv4: The private IPv4 address for the instance (optional)
        :param pulumi.Input[str] public_ip: (String) Instance's public IP address
        :param pulumi.Input[str] public_ip_required: This should be either 'none' or 'create' (default: 'create')
        :param pulumi.Input[int] ram_mb: (Number) Instance's RAM (MB)
        :param pulumi.Input[str] region: The region for the instance, if not declare we use the region in declared in the provider
        :param pulumi.Input[str] reserved_ipv4: Can be either the UUID, name, or the IP address of the reserved IP
        :param pulumi.Input[str] reverse_dns: A fully qualified domain name that should be used as the instance's IP's reverse DNS (optional, uses the hostname if
               unspecified)
        :param pulumi.Input[str] script: The contents of a script that will be uploaded to /usr/local/bin/civo-user-init-script on your instance,
               read/write/executable only by root and then will be executed at the end of the cloud initialization
        :param pulumi.Input[str] size: The name of the size, from the current list, e.g. g3.xsmall
        :param pulumi.Input[str] source_id: (String) Instance's source ID
        :param pulumi.Input[str] source_type: (String) Instance's source type
        :param pulumi.Input[str] sshkey_id: The ID of an already uploaded SSH public key to use for login to the default user (optional; if one isn't provided a
               random password will be set and returned in the initial_password field)
        :param pulumi.Input[str] status: (String) Instance's status
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: An optional list of tags, represented as a key, value pair
        """
        if cpu_cores is not None:
            pulumi.set(__self__, "cpu_cores", cpu_cores)
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if disk_gb is not None:
            pulumi.set(__self__, "disk_gb", disk_gb)
        if disk_image is not None:
            pulumi.set(__self__, "disk_image", disk_image)
        if firewall_id is not None:
            pulumi.set(__self__, "firewall_id", firewall_id)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if initial_password is not None:
            pulumi.set(__self__, "initial_password", initial_password)
        if initial_user is not None:
            pulumi.set(__self__, "initial_user", initial_user)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if notes is not None:
            pulumi.set(__self__, "notes", notes)
        if private_ip is not None:
            pulumi.set(__self__, "private_ip", private_ip)
        if private_ipv4 is not None:
            pulumi.set(__self__, "private_ipv4", private_ipv4)
        if public_ip is not None:
            pulumi.set(__self__, "public_ip", public_ip)
        if public_ip_required is not None:
            pulumi.set(__self__, "public_ip_required", public_ip_required)
        if ram_mb is not None:
            pulumi.set(__self__, "ram_mb", ram_mb)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if reserved_ipv4 is not None:
            pulumi.set(__self__, "reserved_ipv4", reserved_ipv4)
        if reverse_dns is not None:
            pulumi.set(__self__, "reverse_dns", reverse_dns)
        if script is not None:
            pulumi.set(__self__, "script", script)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if source_id is not None:
            pulumi.set(__self__, "source_id", source_id)
        if source_type is not None:
            pulumi.set(__self__, "source_type", source_type)
        if sshkey_id is not None:
            pulumi.set(__self__, "sshkey_id", sshkey_id)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if write_password is not None:
            pulumi.set(__self__, "write_password", write_password)

    @property
    @pulumi.getter(name="cpuCores")
    def cpu_cores(self) -> Optional[pulumi.Input[int]]:
        """
        (Number) Instance's CPU cores
        """
        return pulumi.get(self, "cpu_cores")

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

    @property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[pulumi.Input[str]]:
        """
        (String) Timestamp when the instance was created
        """
        return pulumi.get(self, "created_at")

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

    @property
    @pulumi.getter(name="diskGb")
    def disk_gb(self) -> Optional[pulumi.Input[int]]:
        """
        (Number) Instance's disk (GB)
        """
        return pulumi.get(self, "disk_gb")

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

    @property
    @pulumi.getter(name="diskImage")
    def disk_image(self) -> Optional[pulumi.Input[str]]:
        """
        The ID for the disk image to use to build the instance
        """
        return pulumi.get(self, "disk_image")

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

    @property
    @pulumi.getter(name="firewallId")
    def firewall_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the firewall to use, from the current list. If left blank or not sent, the default firewall will be used (open
        to all)
        """
        return pulumi.get(self, "firewall_id")

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

    @property
    @pulumi.getter
    def hostname(self) -> Optional[pulumi.Input[str]]:
        """
        A fully qualified domain name that should be set as the instance's hostname
        """
        return pulumi.get(self, "hostname")

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

    @property
    @pulumi.getter(name="initialPassword")
    def initial_password(self) -> Optional[pulumi.Input[str]]:
        """
        (String, Sensitive) Initial password for login
        """
        return pulumi.get(self, "initial_password")

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

    @property
    @pulumi.getter(name="initialUser")
    def initial_user(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the initial user created on the server (optional; this will default to the template's default_username and
        fallback to civo)
        """
        return pulumi.get(self, "initial_user")

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

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[pulumi.Input[str]]:
        """
        This must be the ID of the network from the network listing (optional; default network used when not specified)
        """
        return pulumi.get(self, "network_id")

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

    @property
    @pulumi.getter
    def notes(self) -> Optional[pulumi.Input[str]]:
        """
        Add some notes to the instance
        """
        return pulumi.get(self, "notes")

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

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> Optional[pulumi.Input[str]]:
        """
        (String) Instance's private IP address
        """
        return pulumi.get(self, "private_ip")

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

    @property
    @pulumi.getter(name="privateIpv4")
    def private_ipv4(self) -> Optional[pulumi.Input[str]]:
        """
        The private IPv4 address for the instance (optional)
        """
        return pulumi.get(self, "private_ipv4")

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

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> Optional[pulumi.Input[str]]:
        """
        (String) Instance's public IP address
        """
        return pulumi.get(self, "public_ip")

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

    @property
    @pulumi.getter(name="publicIpRequired")
    def public_ip_required(self) -> Optional[pulumi.Input[str]]:
        """
        This should be either 'none' or 'create' (default: 'create')
        """
        return pulumi.get(self, "public_ip_required")

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

    @property
    @pulumi.getter(name="ramMb")
    def ram_mb(self) -> Optional[pulumi.Input[int]]:
        """
        (Number) Instance's RAM (MB)
        """
        return pulumi.get(self, "ram_mb")

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

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        The region for the instance, if not declare we use the region in declared in the provider
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter(name="reservedIpv4")
    def reserved_ipv4(self) -> Optional[pulumi.Input[str]]:
        """
        Can be either the UUID, name, or the IP address of the reserved IP
        """
        return pulumi.get(self, "reserved_ipv4")

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

    @property
    @pulumi.getter(name="reverseDns")
    def reverse_dns(self) -> Optional[pulumi.Input[str]]:
        """
        A fully qualified domain name that should be used as the instance's IP's reverse DNS (optional, uses the hostname if
        unspecified)
        """
        return pulumi.get(self, "reverse_dns")

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

    @property
    @pulumi.getter
    def script(self) -> Optional[pulumi.Input[str]]:
        """
        The contents of a script that will be uploaded to /usr/local/bin/civo-user-init-script on your instance,
        read/write/executable only by root and then will be executed at the end of the cloud initialization
        """
        return pulumi.get(self, "script")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the size, from the current list, e.g. g3.xsmall
        """
        return pulumi.get(self, "size")

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

    @property
    @pulumi.getter(name="sourceId")
    def source_id(self) -> Optional[pulumi.Input[str]]:
        """
        (String) Instance's source ID
        """
        return pulumi.get(self, "source_id")

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

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> Optional[pulumi.Input[str]]:
        """
        (String) Instance's source type
        """
        return pulumi.get(self, "source_type")

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

    @property
    @pulumi.getter(name="sshkeyId")
    def sshkey_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of an already uploaded SSH public key to use for login to the default user (optional; if one isn't provided a
        random password will be set and returned in the initial_password field)
        """
        return pulumi.get(self, "sshkey_id")

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

    @property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[str]]:
        """
        (String) Instance's status
        """
        return pulumi.get(self, "status")

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

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        An optional list of tags, represented as a key, value pair
        """
        return pulumi.get(self, "tags")

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

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

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


class Instance(pulumi.CustomResource):
    @overload
    def __init__(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 disk_image: Optional[pulumi.Input[str]] = None,
                 firewall_id: Optional[pulumi.Input[str]] = None,
                 hostname: Optional[pulumi.Input[str]] = None,
                 initial_user: Optional[pulumi.Input[str]] = None,
                 network_id: Optional[pulumi.Input[str]] = None,
                 notes: Optional[pulumi.Input[str]] = None,
                 private_ipv4: Optional[pulumi.Input[str]] = None,
                 public_ip_required: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 reserved_ipv4: Optional[pulumi.Input[str]] = None,
                 reverse_dns: Optional[pulumi.Input[str]] = None,
                 script: Optional[pulumi.Input[str]] = None,
                 size: Optional[pulumi.Input[str]] = None,
                 sshkey_id: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 write_password: Optional[pulumi.Input[bool]] = None,
                 __props__=None):
        """
        Provides a Civo instance resource. This can be used to create, modify, and delete instances.

        ## Example Usage

        * View instances after creation on the [CLI](https://www.civo.com/docs/overview/civo-cli):
        * View instances after creation on the [Dashboard](https://dashboard.civo.com/instances)
        * View node sizes on [CLI](https://www.civo.com/docs/overview/civo-cli):

        ### Simple and smallest instance with its own network

        ```python
        import pulumi
        import pulumi_civo as civo

        example_network = civo.Network("example", label="example-network")
        example = civo.Firewall("example",
            name="example-firewall",
            create_default_rules=True,
            network_id=example_network.id)
        # Query instance disk image
        debian = civo.get_disk_image(filters=[{
            "key": "name",
            "values": ["debian-10"],
        }])
        # Create a new instance
        example_instance = civo.Instance("example",
            hostname="example",
            tags=[
                "example",
                "documentation",
            ],
            notes="This is an example instance",
            firewall_id=example.id,
            network_id=example_network.id,
            size="g3.xsmall",
            disk_image=debian.diskimages[0].id)
        ```

        With this configuration, an initial password for the instance gets written to the state on output `initial_password` which you can use to access the instance.

        Alternative you can get the password with the [CLI](https://www.civo.com/docs/overview/civo-cli):

        ### Instance with ssh login

        ```python
        import pulumi
        import pulumi_civo as civo
        import pulumi_std as std

        example_network = civo.Network("example", label="example-network")
        example = civo.Firewall("example",
            name="example-firewall",
            create_default_rules=True,
            network_id=example_network.id)
        # Query instance disk image
        debian = civo.get_disk_image(filters=[{
            "key": "name",
            "values": ["debian-10"],
        }])
        # To create the example key, run this command:
        # ssh-keygen -f ~/.ssh/example-tf -C "terraform-example@localmachine"
        example_ssh_key = civo.SshKey("example",
            name="example",
            public_key=std.file(input="~/.ssh/example-tf.pub").result)
        # Create a new instance
        example_instance = civo.Instance("example",
            hostname="example",
            tags=[
                "example",
                "documentation",
            ],
            notes="This is an example instance",
            sshkey_id=example_ssh_key.id,
            firewall_id=example.id,
            network_id=example_network.id,
            size="g3.xsmall",
            disk_image=debian.diskimages[0].id)
        ```

        ## Import

        using ID

        ```sh
        $ pulumi import civo:index/instance:Instance example 18bd98ad-1b6e-4f87-b48f-e690b4fd7413
        ```

        :param str resource_name: The name of the resource.
        :param pulumi.ResourceOptions opts: Options for the resource.
        :param pulumi.Input[str] disk_image: The ID for the disk image to use to build the instance
        :param pulumi.Input[str] firewall_id: The ID of the firewall to use, from the current list. If left blank or not sent, the default firewall will be used (open
               to all)
        :param pulumi.Input[str] hostname: A fully qualified domain name that should be set as the instance's hostname
        :param pulumi.Input[str] initial_user: The name of the initial user created on the server (optional; this will default to the template's default_username and
               fallback to civo)
        :param pulumi.Input[str] network_id: This must be the ID of the network from the network listing (optional; default network used when not specified)
        :param pulumi.Input[str] notes: Add some notes to the instance
        :param pulumi.Input[str] private_ipv4: The private IPv4 address for the instance (optional)
        :param pulumi.Input[str] public_ip_required: This should be either 'none' or 'create' (default: 'create')
        :param pulumi.Input[str] region: The region for the instance, if not declare we use the region in declared in the provider
        :param pulumi.Input[str] reserved_ipv4: Can be either the UUID, name, or the IP address of the reserved IP
        :param pulumi.Input[str] reverse_dns: A fully qualified domain name that should be used as the instance's IP's reverse DNS (optional, uses the hostname if
               unspecified)
        :param pulumi.Input[str] script: The contents of a script that will be uploaded to /usr/local/bin/civo-user-init-script on your instance,
               read/write/executable only by root and then will be executed at the end of the cloud initialization
        :param pulumi.Input[str] size: The name of the size, from the current list, e.g. g3.xsmall
        :param pulumi.Input[str] sshkey_id: The ID of an already uploaded SSH public key to use for login to the default user (optional; if one isn't provided a
               random password will be set and returned in the initial_password field)
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: An optional list of tags, represented as a key, value pair
        """
        ...
    @overload
    def __init__(__self__,
                 resource_name: str,
                 args: InstanceArgs,
                 opts: Optional[pulumi.ResourceOptions] = None):
        """
        Provides a Civo instance resource. This can be used to create, modify, and delete instances.

        ## Example Usage

        * View instances after creation on the [CLI](https://www.civo.com/docs/overview/civo-cli):
        * View instances after creation on the [Dashboard](https://dashboard.civo.com/instances)
        * View node sizes on [CLI](https://www.civo.com/docs/overview/civo-cli):

        ### Simple and smallest instance with its own network

        ```python
        import pulumi
        import pulumi_civo as civo

        example_network = civo.Network("example", label="example-network")
        example = civo.Firewall("example",
            name="example-firewall",
            create_default_rules=True,
            network_id=example_network.id)
        # Query instance disk image
        debian = civo.get_disk_image(filters=[{
            "key": "name",
            "values": ["debian-10"],
        }])
        # Create a new instance
        example_instance = civo.Instance("example",
            hostname="example",
            tags=[
                "example",
                "documentation",
            ],
            notes="This is an example instance",
            firewall_id=example.id,
            network_id=example_network.id,
            size="g3.xsmall",
            disk_image=debian.diskimages[0].id)
        ```

        With this configuration, an initial password for the instance gets written to the state on output `initial_password` which you can use to access the instance.

        Alternative you can get the password with the [CLI](https://www.civo.com/docs/overview/civo-cli):

        ### Instance with ssh login

        ```python
        import pulumi
        import pulumi_civo as civo
        import pulumi_std as std

        example_network = civo.Network("example", label="example-network")
        example = civo.Firewall("example",
            name="example-firewall",
            create_default_rules=True,
            network_id=example_network.id)
        # Query instance disk image
        debian = civo.get_disk_image(filters=[{
            "key": "name",
            "values": ["debian-10"],
        }])
        # To create the example key, run this command:
        # ssh-keygen -f ~/.ssh/example-tf -C "terraform-example@localmachine"
        example_ssh_key = civo.SshKey("example",
            name="example",
            public_key=std.file(input="~/.ssh/example-tf.pub").result)
        # Create a new instance
        example_instance = civo.Instance("example",
            hostname="example",
            tags=[
                "example",
                "documentation",
            ],
            notes="This is an example instance",
            sshkey_id=example_ssh_key.id,
            firewall_id=example.id,
            network_id=example_network.id,
            size="g3.xsmall",
            disk_image=debian.diskimages[0].id)
        ```

        ## Import

        using ID

        ```sh
        $ pulumi import civo:index/instance:Instance example 18bd98ad-1b6e-4f87-b48f-e690b4fd7413
        ```

        :param str resource_name: The name of the resource.
        :param InstanceArgs args: The arguments to use to populate this resource's properties.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        ...
    def __init__(__self__, resource_name: str, *args, **kwargs):
        resource_args, opts = _utilities.get_resource_args_opts(InstanceArgs, pulumi.ResourceOptions, *args, **kwargs)
        if resource_args is not None:
            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
        else:
            __self__._internal_init(resource_name, *args, **kwargs)

    def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 disk_image: Optional[pulumi.Input[str]] = None,
                 firewall_id: Optional[pulumi.Input[str]] = None,
                 hostname: Optional[pulumi.Input[str]] = None,
                 initial_user: Optional[pulumi.Input[str]] = None,
                 network_id: Optional[pulumi.Input[str]] = None,
                 notes: Optional[pulumi.Input[str]] = None,
                 private_ipv4: Optional[pulumi.Input[str]] = None,
                 public_ip_required: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 reserved_ipv4: Optional[pulumi.Input[str]] = None,
                 reverse_dns: Optional[pulumi.Input[str]] = None,
                 script: Optional[pulumi.Input[str]] = None,
                 size: Optional[pulumi.Input[str]] = None,
                 sshkey_id: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 write_password: Optional[pulumi.Input[bool]] = None,
                 __props__=None):
        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = InstanceArgs.__new__(InstanceArgs)

            if disk_image is None and not opts.urn:
                raise TypeError("Missing required property 'disk_image'")
            __props__.__dict__["disk_image"] = disk_image
            if firewall_id is None and not opts.urn:
                raise TypeError("Missing required property 'firewall_id'")
            __props__.__dict__["firewall_id"] = firewall_id
            __props__.__dict__["hostname"] = hostname
            __props__.__dict__["initial_user"] = initial_user
            __props__.__dict__["network_id"] = network_id
            __props__.__dict__["notes"] = notes
            __props__.__dict__["private_ipv4"] = private_ipv4
            __props__.__dict__["public_ip_required"] = public_ip_required
            __props__.__dict__["region"] = region
            __props__.__dict__["reserved_ipv4"] = reserved_ipv4
            __props__.__dict__["reverse_dns"] = reverse_dns
            __props__.__dict__["script"] = script
            __props__.__dict__["size"] = size
            __props__.__dict__["sshkey_id"] = sshkey_id
            __props__.__dict__["tags"] = tags
            __props__.__dict__["write_password"] = write_password
            __props__.__dict__["cpu_cores"] = None
            __props__.__dict__["created_at"] = None
            __props__.__dict__["disk_gb"] = None
            __props__.__dict__["initial_password"] = None
            __props__.__dict__["private_ip"] = None
            __props__.__dict__["public_ip"] = None
            __props__.__dict__["ram_mb"] = None
            __props__.__dict__["source_id"] = None
            __props__.__dict__["source_type"] = None
            __props__.__dict__["status"] = None
        secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["initialPassword"])
        opts = pulumi.ResourceOptions.merge(opts, secret_opts)
        super(Instance, __self__).__init__(
            'civo:index/instance:Instance',
            resource_name,
            __props__,
            opts)

    @staticmethod
    def get(resource_name: str,
            id: pulumi.Input[str],
            opts: Optional[pulumi.ResourceOptions] = None,
            cpu_cores: Optional[pulumi.Input[int]] = None,
            created_at: Optional[pulumi.Input[str]] = None,
            disk_gb: Optional[pulumi.Input[int]] = None,
            disk_image: Optional[pulumi.Input[str]] = None,
            firewall_id: Optional[pulumi.Input[str]] = None,
            hostname: Optional[pulumi.Input[str]] = None,
            initial_password: Optional[pulumi.Input[str]] = None,
            initial_user: Optional[pulumi.Input[str]] = None,
            network_id: Optional[pulumi.Input[str]] = None,
            notes: Optional[pulumi.Input[str]] = None,
            private_ip: Optional[pulumi.Input[str]] = None,
            private_ipv4: Optional[pulumi.Input[str]] = None,
            public_ip: Optional[pulumi.Input[str]] = None,
            public_ip_required: Optional[pulumi.Input[str]] = None,
            ram_mb: Optional[pulumi.Input[int]] = None,
            region: Optional[pulumi.Input[str]] = None,
            reserved_ipv4: Optional[pulumi.Input[str]] = None,
            reverse_dns: Optional[pulumi.Input[str]] = None,
            script: Optional[pulumi.Input[str]] = None,
            size: Optional[pulumi.Input[str]] = None,
            source_id: Optional[pulumi.Input[str]] = None,
            source_type: Optional[pulumi.Input[str]] = None,
            sshkey_id: Optional[pulumi.Input[str]] = None,
            status: Optional[pulumi.Input[str]] = None,
            tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
            write_password: Optional[pulumi.Input[bool]] = None) -> 'Instance':
        """
        Get an existing Instance resource's state with the given name, id, and optional extra
        properties used to qualify the lookup.

        :param str resource_name: The unique name of the resulting resource.
        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
        :param pulumi.ResourceOptions opts: Options for the resource.
        :param pulumi.Input[int] cpu_cores: (Number) Instance's CPU cores
        :param pulumi.Input[str] created_at: (String) Timestamp when the instance was created
        :param pulumi.Input[int] disk_gb: (Number) Instance's disk (GB)
        :param pulumi.Input[str] disk_image: The ID for the disk image to use to build the instance
        :param pulumi.Input[str] firewall_id: The ID of the firewall to use, from the current list. If left blank or not sent, the default firewall will be used (open
               to all)
        :param pulumi.Input[str] hostname: A fully qualified domain name that should be set as the instance's hostname
        :param pulumi.Input[str] initial_password: (String, Sensitive) Initial password for login
        :param pulumi.Input[str] initial_user: The name of the initial user created on the server (optional; this will default to the template's default_username and
               fallback to civo)
        :param pulumi.Input[str] network_id: This must be the ID of the network from the network listing (optional; default network used when not specified)
        :param pulumi.Input[str] notes: Add some notes to the instance
        :param pulumi.Input[str] private_ip: (String) Instance's private IP address
        :param pulumi.Input[str] private_ipv4: The private IPv4 address for the instance (optional)
        :param pulumi.Input[str] public_ip: (String) Instance's public IP address
        :param pulumi.Input[str] public_ip_required: This should be either 'none' or 'create' (default: 'create')
        :param pulumi.Input[int] ram_mb: (Number) Instance's RAM (MB)
        :param pulumi.Input[str] region: The region for the instance, if not declare we use the region in declared in the provider
        :param pulumi.Input[str] reserved_ipv4: Can be either the UUID, name, or the IP address of the reserved IP
        :param pulumi.Input[str] reverse_dns: A fully qualified domain name that should be used as the instance's IP's reverse DNS (optional, uses the hostname if
               unspecified)
        :param pulumi.Input[str] script: The contents of a script that will be uploaded to /usr/local/bin/civo-user-init-script on your instance,
               read/write/executable only by root and then will be executed at the end of the cloud initialization
        :param pulumi.Input[str] size: The name of the size, from the current list, e.g. g3.xsmall
        :param pulumi.Input[str] source_id: (String) Instance's source ID
        :param pulumi.Input[str] source_type: (String) Instance's source type
        :param pulumi.Input[str] sshkey_id: The ID of an already uploaded SSH public key to use for login to the default user (optional; if one isn't provided a
               random password will be set and returned in the initial_password field)
        :param pulumi.Input[str] status: (String) Instance's status
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: An optional list of tags, represented as a key, value pair
        """
        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))

        __props__ = _InstanceState.__new__(_InstanceState)

        __props__.__dict__["cpu_cores"] = cpu_cores
        __props__.__dict__["created_at"] = created_at
        __props__.__dict__["disk_gb"] = disk_gb
        __props__.__dict__["disk_image"] = disk_image
        __props__.__dict__["firewall_id"] = firewall_id
        __props__.__dict__["hostname"] = hostname
        __props__.__dict__["initial_password"] = initial_password
        __props__.__dict__["initial_user"] = initial_user
        __props__.__dict__["network_id"] = network_id
        __props__.__dict__["notes"] = notes
        __props__.__dict__["private_ip"] = private_ip
        __props__.__dict__["private_ipv4"] = private_ipv4
        __props__.__dict__["public_ip"] = public_ip
        __props__.__dict__["public_ip_required"] = public_ip_required
        __props__.__dict__["ram_mb"] = ram_mb
        __props__.__dict__["region"] = region
        __props__.__dict__["reserved_ipv4"] = reserved_ipv4
        __props__.__dict__["reverse_dns"] = reverse_dns
        __props__.__dict__["script"] = script
        __props__.__dict__["size"] = size
        __props__.__dict__["source_id"] = source_id
        __props__.__dict__["source_type"] = source_type
        __props__.__dict__["sshkey_id"] = sshkey_id
        __props__.__dict__["status"] = status
        __props__.__dict__["tags"] = tags
        __props__.__dict__["write_password"] = write_password
        return Instance(resource_name, opts=opts, __props__=__props__)

    @property
    @pulumi.getter(name="cpuCores")
    def cpu_cores(self) -> pulumi.Output[int]:
        """
        (Number) Instance's CPU cores
        """
        return pulumi.get(self, "cpu_cores")

    @property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> pulumi.Output[str]:
        """
        (String) Timestamp when the instance was created
        """
        return pulumi.get(self, "created_at")

    @property
    @pulumi.getter(name="diskGb")
    def disk_gb(self) -> pulumi.Output[int]:
        """
        (Number) Instance's disk (GB)
        """
        return pulumi.get(self, "disk_gb")

    @property
    @pulumi.getter(name="diskImage")
    def disk_image(self) -> pulumi.Output[str]:
        """
        The ID for the disk image to use to build the instance
        """
        return pulumi.get(self, "disk_image")

    @property
    @pulumi.getter(name="firewallId")
    def firewall_id(self) -> pulumi.Output[str]:
        """
        The ID of the firewall to use, from the current list. If left blank or not sent, the default firewall will be used (open
        to all)
        """
        return pulumi.get(self, "firewall_id")

    @property
    @pulumi.getter
    def hostname(self) -> pulumi.Output[str]:
        """
        A fully qualified domain name that should be set as the instance's hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter(name="initialPassword")
    def initial_password(self) -> pulumi.Output[str]:
        """
        (String, Sensitive) Initial password for login
        """
        return pulumi.get(self, "initial_password")

    @property
    @pulumi.getter(name="initialUser")
    def initial_user(self) -> pulumi.Output[Optional[str]]:
        """
        The name of the initial user created on the server (optional; this will default to the template's default_username and
        fallback to civo)
        """
        return pulumi.get(self, "initial_user")

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> pulumi.Output[str]:
        """
        This must be the ID of the network from the network listing (optional; default network used when not specified)
        """
        return pulumi.get(self, "network_id")

    @property
    @pulumi.getter
    def notes(self) -> pulumi.Output[Optional[str]]:
        """
        Add some notes to the instance
        """
        return pulumi.get(self, "notes")

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> pulumi.Output[str]:
        """
        (String) Instance's private IP address
        """
        return pulumi.get(self, "private_ip")

    @property
    @pulumi.getter(name="privateIpv4")
    def private_ipv4(self) -> pulumi.Output[Optional[str]]:
        """
        The private IPv4 address for the instance (optional)
        """
        return pulumi.get(self, "private_ipv4")

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> pulumi.Output[str]:
        """
        (String) Instance's public IP address
        """
        return pulumi.get(self, "public_ip")

    @property
    @pulumi.getter(name="publicIpRequired")
    def public_ip_required(self) -> pulumi.Output[Optional[str]]:
        """
        This should be either 'none' or 'create' (default: 'create')
        """
        return pulumi.get(self, "public_ip_required")

    @property
    @pulumi.getter(name="ramMb")
    def ram_mb(self) -> pulumi.Output[int]:
        """
        (Number) Instance's RAM (MB)
        """
        return pulumi.get(self, "ram_mb")

    @property
    @pulumi.getter
    def region(self) -> pulumi.Output[Optional[str]]:
        """
        The region for the instance, if not declare we use the region in declared in the provider
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="reservedIpv4")
    def reserved_ipv4(self) -> pulumi.Output[Optional[str]]:
        """
        Can be either the UUID, name, or the IP address of the reserved IP
        """
        return pulumi.get(self, "reserved_ipv4")

    @property
    @pulumi.getter(name="reverseDns")
    def reverse_dns(self) -> pulumi.Output[Optional[str]]:
        """
        A fully qualified domain name that should be used as the instance's IP's reverse DNS (optional, uses the hostname if
        unspecified)
        """
        return pulumi.get(self, "reverse_dns")

    @property
    @pulumi.getter
    def script(self) -> pulumi.Output[Optional[str]]:
        """
        The contents of a script that will be uploaded to /usr/local/bin/civo-user-init-script on your instance,
        read/write/executable only by root and then will be executed at the end of the cloud initialization
        """
        return pulumi.get(self, "script")

    @property
    @pulumi.getter
    def size(self) -> pulumi.Output[Optional[str]]:
        """
        The name of the size, from the current list, e.g. g3.xsmall
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sourceId")
    def source_id(self) -> pulumi.Output[str]:
        """
        (String) Instance's source ID
        """
        return pulumi.get(self, "source_id")

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> pulumi.Output[str]:
        """
        (String) Instance's source type
        """
        return pulumi.get(self, "source_type")

    @property
    @pulumi.getter(name="sshkeyId")
    def sshkey_id(self) -> pulumi.Output[str]:
        """
        The ID of an already uploaded SSH public key to use for login to the default user (optional; if one isn't provided a
        random password will be set and returned in the initial_password field)
        """
        return pulumi.get(self, "sshkey_id")

    @property
    @pulumi.getter
    def status(self) -> pulumi.Output[str]:
        """
        (String) Instance's status
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def tags(self) -> pulumi.Output[Optional[Sequence[str]]]:
        """
        An optional list of tags, represented as a key, value pair
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="writePassword")
    def write_password(self) -> pulumi.Output[Optional[bool]]:
        return pulumi.get(self, "write_password")

