# 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 sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'GetAutonomousDatabaseResult',
    'AwaitableGetAutonomousDatabaseResult',
    'get_autonomous_database',
    'get_autonomous_database_output',
]

@pulumi.output_type
class GetAutonomousDatabaseResult:
    """
    A collection of values returned by getAutonomousDatabase.
    """
    def __init__(__self__, actual_used_data_storage_size_in_tbs=None, allocated_storage_size_in_tbs=None, allowed_ips=None, auto_scaling_enabled=None, auto_scaling_for_storage_enabled=None, autonomous_database_id=None, available_upgrade_versions=None, backup_retention_period_in_days=None, character_set=None, compute_count=None, cpu_core_count=None, data_storage_size_in_gbs=None, data_storage_size_in_tbs=None, db_node_storage_size_in_gbs=None, db_version=None, display_name=None, failed_data_recovery_in_seconds=None, id=None, in_memory_area_in_gbs=None, lifecycle_details=None, local_adg_auto_failover_max_data_loss_limit=None, local_data_guard_enabled=None, location=None, memory_per_oracle_compute_unit_in_gbs=None, mtls_connection_required=None, name=None, national_character_set=None, next_long_term_backup_time_stamp=None, oci_url=None, ocid=None, peer_db_id=None, peer_db_ids=None, preview=None, preview_version_with_service_terms_accepted=None, private_endpoint=None, private_endpoint_ip=None, private_endpoint_label=None, provisionable_cpuses=None, remote_data_guard_enabled=None, resource_group_name=None, service_console_url=None, sql_web_developer_url=None, subnet_id=None, supported_regions_to_clone_tos=None, tags=None, time_created=None, time_data_guard_role_changed=None, time_deletion_of_free_autonomous_database=None, time_local_data_guard_enabled_on=None, time_maintenance_begin=None, time_maintenance_end=None, time_of_last_failover=None, time_of_last_refresh=None, time_of_last_refresh_point=None, time_of_last_switchover=None, time_reclamation_of_free_autonomous_database=None, used_data_storage_size_in_gbs=None, used_data_storage_size_in_tbs=None, virtual_network_id=None):
        if actual_used_data_storage_size_in_tbs and not isinstance(actual_used_data_storage_size_in_tbs, float):
            raise TypeError("Expected argument 'actual_used_data_storage_size_in_tbs' to be a float")
        pulumi.set(__self__, "actual_used_data_storage_size_in_tbs", actual_used_data_storage_size_in_tbs)
        if allocated_storage_size_in_tbs and not isinstance(allocated_storage_size_in_tbs, float):
            raise TypeError("Expected argument 'allocated_storage_size_in_tbs' to be a float")
        pulumi.set(__self__, "allocated_storage_size_in_tbs", allocated_storage_size_in_tbs)
        if allowed_ips and not isinstance(allowed_ips, list):
            raise TypeError("Expected argument 'allowed_ips' to be a list")
        pulumi.set(__self__, "allowed_ips", allowed_ips)
        if auto_scaling_enabled and not isinstance(auto_scaling_enabled, bool):
            raise TypeError("Expected argument 'auto_scaling_enabled' to be a bool")
        pulumi.set(__self__, "auto_scaling_enabled", auto_scaling_enabled)
        if auto_scaling_for_storage_enabled and not isinstance(auto_scaling_for_storage_enabled, bool):
            raise TypeError("Expected argument 'auto_scaling_for_storage_enabled' to be a bool")
        pulumi.set(__self__, "auto_scaling_for_storage_enabled", auto_scaling_for_storage_enabled)
        if autonomous_database_id and not isinstance(autonomous_database_id, str):
            raise TypeError("Expected argument 'autonomous_database_id' to be a str")
        pulumi.set(__self__, "autonomous_database_id", autonomous_database_id)
        if available_upgrade_versions and not isinstance(available_upgrade_versions, list):
            raise TypeError("Expected argument 'available_upgrade_versions' to be a list")
        pulumi.set(__self__, "available_upgrade_versions", available_upgrade_versions)
        if backup_retention_period_in_days and not isinstance(backup_retention_period_in_days, int):
            raise TypeError("Expected argument 'backup_retention_period_in_days' to be a int")
        pulumi.set(__self__, "backup_retention_period_in_days", backup_retention_period_in_days)
        if character_set and not isinstance(character_set, str):
            raise TypeError("Expected argument 'character_set' to be a str")
        pulumi.set(__self__, "character_set", character_set)
        if compute_count and not isinstance(compute_count, float):
            raise TypeError("Expected argument 'compute_count' to be a float")
        pulumi.set(__self__, "compute_count", compute_count)
        if cpu_core_count and not isinstance(cpu_core_count, int):
            raise TypeError("Expected argument 'cpu_core_count' to be a int")
        pulumi.set(__self__, "cpu_core_count", cpu_core_count)
        if data_storage_size_in_gbs and not isinstance(data_storage_size_in_gbs, int):
            raise TypeError("Expected argument 'data_storage_size_in_gbs' to be a int")
        pulumi.set(__self__, "data_storage_size_in_gbs", data_storage_size_in_gbs)
        if data_storage_size_in_tbs and not isinstance(data_storage_size_in_tbs, int):
            raise TypeError("Expected argument 'data_storage_size_in_tbs' to be a int")
        pulumi.set(__self__, "data_storage_size_in_tbs", data_storage_size_in_tbs)
        if db_node_storage_size_in_gbs and not isinstance(db_node_storage_size_in_gbs, int):
            raise TypeError("Expected argument 'db_node_storage_size_in_gbs' to be a int")
        pulumi.set(__self__, "db_node_storage_size_in_gbs", db_node_storage_size_in_gbs)
        if db_version and not isinstance(db_version, str):
            raise TypeError("Expected argument 'db_version' to be a str")
        pulumi.set(__self__, "db_version", db_version)
        if display_name and not isinstance(display_name, str):
            raise TypeError("Expected argument 'display_name' to be a str")
        pulumi.set(__self__, "display_name", display_name)
        if failed_data_recovery_in_seconds and not isinstance(failed_data_recovery_in_seconds, int):
            raise TypeError("Expected argument 'failed_data_recovery_in_seconds' to be a int")
        pulumi.set(__self__, "failed_data_recovery_in_seconds", failed_data_recovery_in_seconds)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if in_memory_area_in_gbs and not isinstance(in_memory_area_in_gbs, int):
            raise TypeError("Expected argument 'in_memory_area_in_gbs' to be a int")
        pulumi.set(__self__, "in_memory_area_in_gbs", in_memory_area_in_gbs)
        if lifecycle_details and not isinstance(lifecycle_details, str):
            raise TypeError("Expected argument 'lifecycle_details' to be a str")
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        if local_adg_auto_failover_max_data_loss_limit and not isinstance(local_adg_auto_failover_max_data_loss_limit, int):
            raise TypeError("Expected argument 'local_adg_auto_failover_max_data_loss_limit' to be a int")
        pulumi.set(__self__, "local_adg_auto_failover_max_data_loss_limit", local_adg_auto_failover_max_data_loss_limit)
        if local_data_guard_enabled and not isinstance(local_data_guard_enabled, bool):
            raise TypeError("Expected argument 'local_data_guard_enabled' to be a bool")
        pulumi.set(__self__, "local_data_guard_enabled", local_data_guard_enabled)
        if location and not isinstance(location, str):
            raise TypeError("Expected argument 'location' to be a str")
        pulumi.set(__self__, "location", location)
        if memory_per_oracle_compute_unit_in_gbs and not isinstance(memory_per_oracle_compute_unit_in_gbs, int):
            raise TypeError("Expected argument 'memory_per_oracle_compute_unit_in_gbs' to be a int")
        pulumi.set(__self__, "memory_per_oracle_compute_unit_in_gbs", memory_per_oracle_compute_unit_in_gbs)
        if mtls_connection_required and not isinstance(mtls_connection_required, bool):
            raise TypeError("Expected argument 'mtls_connection_required' to be a bool")
        pulumi.set(__self__, "mtls_connection_required", mtls_connection_required)
        if name and not isinstance(name, str):
            raise TypeError("Expected argument 'name' to be a str")
        pulumi.set(__self__, "name", name)
        if national_character_set and not isinstance(national_character_set, str):
            raise TypeError("Expected argument 'national_character_set' to be a str")
        pulumi.set(__self__, "national_character_set", national_character_set)
        if next_long_term_backup_time_stamp and not isinstance(next_long_term_backup_time_stamp, str):
            raise TypeError("Expected argument 'next_long_term_backup_time_stamp' to be a str")
        pulumi.set(__self__, "next_long_term_backup_time_stamp", next_long_term_backup_time_stamp)
        if oci_url and not isinstance(oci_url, str):
            raise TypeError("Expected argument 'oci_url' to be a str")
        pulumi.set(__self__, "oci_url", oci_url)
        if ocid and not isinstance(ocid, str):
            raise TypeError("Expected argument 'ocid' to be a str")
        pulumi.set(__self__, "ocid", ocid)
        if peer_db_id and not isinstance(peer_db_id, str):
            raise TypeError("Expected argument 'peer_db_id' to be a str")
        pulumi.set(__self__, "peer_db_id", peer_db_id)
        if peer_db_ids and not isinstance(peer_db_ids, list):
            raise TypeError("Expected argument 'peer_db_ids' to be a list")
        pulumi.set(__self__, "peer_db_ids", peer_db_ids)
        if preview and not isinstance(preview, bool):
            raise TypeError("Expected argument 'preview' to be a bool")
        pulumi.set(__self__, "preview", preview)
        if preview_version_with_service_terms_accepted and not isinstance(preview_version_with_service_terms_accepted, bool):
            raise TypeError("Expected argument 'preview_version_with_service_terms_accepted' to be a bool")
        pulumi.set(__self__, "preview_version_with_service_terms_accepted", preview_version_with_service_terms_accepted)
        if private_endpoint and not isinstance(private_endpoint, str):
            raise TypeError("Expected argument 'private_endpoint' to be a str")
        pulumi.set(__self__, "private_endpoint", private_endpoint)
        if private_endpoint_ip and not isinstance(private_endpoint_ip, str):
            raise TypeError("Expected argument 'private_endpoint_ip' to be a str")
        pulumi.set(__self__, "private_endpoint_ip", private_endpoint_ip)
        if private_endpoint_label and not isinstance(private_endpoint_label, str):
            raise TypeError("Expected argument 'private_endpoint_label' to be a str")
        pulumi.set(__self__, "private_endpoint_label", private_endpoint_label)
        if provisionable_cpuses and not isinstance(provisionable_cpuses, list):
            raise TypeError("Expected argument 'provisionable_cpuses' to be a list")
        pulumi.set(__self__, "provisionable_cpuses", provisionable_cpuses)
        if remote_data_guard_enabled and not isinstance(remote_data_guard_enabled, bool):
            raise TypeError("Expected argument 'remote_data_guard_enabled' to be a bool")
        pulumi.set(__self__, "remote_data_guard_enabled", remote_data_guard_enabled)
        if resource_group_name and not isinstance(resource_group_name, str):
            raise TypeError("Expected argument 'resource_group_name' to be a str")
        pulumi.set(__self__, "resource_group_name", resource_group_name)
        if service_console_url and not isinstance(service_console_url, str):
            raise TypeError("Expected argument 'service_console_url' to be a str")
        pulumi.set(__self__, "service_console_url", service_console_url)
        if sql_web_developer_url and not isinstance(sql_web_developer_url, str):
            raise TypeError("Expected argument 'sql_web_developer_url' to be a str")
        pulumi.set(__self__, "sql_web_developer_url", sql_web_developer_url)
        if subnet_id and not isinstance(subnet_id, str):
            raise TypeError("Expected argument 'subnet_id' to be a str")
        pulumi.set(__self__, "subnet_id", subnet_id)
        if supported_regions_to_clone_tos and not isinstance(supported_regions_to_clone_tos, list):
            raise TypeError("Expected argument 'supported_regions_to_clone_tos' to be a list")
        pulumi.set(__self__, "supported_regions_to_clone_tos", supported_regions_to_clone_tos)
        if tags and not isinstance(tags, dict):
            raise TypeError("Expected argument 'tags' to be a dict")
        pulumi.set(__self__, "tags", tags)
        if time_created and not isinstance(time_created, str):
            raise TypeError("Expected argument 'time_created' to be a str")
        pulumi.set(__self__, "time_created", time_created)
        if time_data_guard_role_changed and not isinstance(time_data_guard_role_changed, str):
            raise TypeError("Expected argument 'time_data_guard_role_changed' to be a str")
        pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
        if time_deletion_of_free_autonomous_database and not isinstance(time_deletion_of_free_autonomous_database, str):
            raise TypeError("Expected argument 'time_deletion_of_free_autonomous_database' to be a str")
        pulumi.set(__self__, "time_deletion_of_free_autonomous_database", time_deletion_of_free_autonomous_database)
        if time_local_data_guard_enabled_on and not isinstance(time_local_data_guard_enabled_on, str):
            raise TypeError("Expected argument 'time_local_data_guard_enabled_on' to be a str")
        pulumi.set(__self__, "time_local_data_guard_enabled_on", time_local_data_guard_enabled_on)
        if time_maintenance_begin and not isinstance(time_maintenance_begin, str):
            raise TypeError("Expected argument 'time_maintenance_begin' to be a str")
        pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
        if time_maintenance_end and not isinstance(time_maintenance_end, str):
            raise TypeError("Expected argument 'time_maintenance_end' to be a str")
        pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
        if time_of_last_failover and not isinstance(time_of_last_failover, str):
            raise TypeError("Expected argument 'time_of_last_failover' to be a str")
        pulumi.set(__self__, "time_of_last_failover", time_of_last_failover)
        if time_of_last_refresh and not isinstance(time_of_last_refresh, str):
            raise TypeError("Expected argument 'time_of_last_refresh' to be a str")
        pulumi.set(__self__, "time_of_last_refresh", time_of_last_refresh)
        if time_of_last_refresh_point and not isinstance(time_of_last_refresh_point, str):
            raise TypeError("Expected argument 'time_of_last_refresh_point' to be a str")
        pulumi.set(__self__, "time_of_last_refresh_point", time_of_last_refresh_point)
        if time_of_last_switchover and not isinstance(time_of_last_switchover, str):
            raise TypeError("Expected argument 'time_of_last_switchover' to be a str")
        pulumi.set(__self__, "time_of_last_switchover", time_of_last_switchover)
        if time_reclamation_of_free_autonomous_database and not isinstance(time_reclamation_of_free_autonomous_database, str):
            raise TypeError("Expected argument 'time_reclamation_of_free_autonomous_database' to be a str")
        pulumi.set(__self__, "time_reclamation_of_free_autonomous_database", time_reclamation_of_free_autonomous_database)
        if used_data_storage_size_in_gbs and not isinstance(used_data_storage_size_in_gbs, int):
            raise TypeError("Expected argument 'used_data_storage_size_in_gbs' to be a int")
        pulumi.set(__self__, "used_data_storage_size_in_gbs", used_data_storage_size_in_gbs)
        if used_data_storage_size_in_tbs and not isinstance(used_data_storage_size_in_tbs, int):
            raise TypeError("Expected argument 'used_data_storage_size_in_tbs' to be a int")
        pulumi.set(__self__, "used_data_storage_size_in_tbs", used_data_storage_size_in_tbs)
        if virtual_network_id and not isinstance(virtual_network_id, str):
            raise TypeError("Expected argument 'virtual_network_id' to be a str")
        pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter(name="actualUsedDataStorageSizeInTbs")
    def actual_used_data_storage_size_in_tbs(self) -> float:
        """
        The current amount of storage in use for user and system data, in terabytes (TB).
        """
        return pulumi.get(self, "actual_used_data_storage_size_in_tbs")

    @property
    @pulumi.getter(name="allocatedStorageSizeInTbs")
    def allocated_storage_size_in_tbs(self) -> float:
        """
        The amount of storage currently allocated for the database tables and billed for, rounded up. When auto-scaling is not enabled, this value is equal to the `dataStorageSizeInTBs` value. You can compare this value to the `actualUsedDataStorageSizeInTBs` value to determine if a manual shrink operation is appropriate for your allocated storage.
        """
        return pulumi.get(self, "allocated_storage_size_in_tbs")

    @property
    @pulumi.getter(name="allowedIps")
    def allowed_ips(self) -> Sequence[int]:
        """
        The client IP access control list (ACL). This feature is available for [Autonomous Database Serverless] (https://docs.oracle.com/en/cloud/paas/autonomous-database/index.html) and on Exadata Cloud@Customer. Only clients connecting from an IP address included in the ACL may access the Autonomous Database instance. If `arePrimaryWhitelistedIpsUsed` is 'TRUE' then Autonomous Database uses this primary's IP access control list (ACL) for the disaster recovery peer called `standbywhitelistedips`.
        """
        return pulumi.get(self, "allowed_ips")

    @property
    @pulumi.getter(name="autoScalingEnabled")
    def auto_scaling_enabled(self) -> bool:
        """
        Indicates if auto scaling is enabled for the Autonomous Database CPU core count.
        """
        return pulumi.get(self, "auto_scaling_enabled")

    @property
    @pulumi.getter(name="autoScalingForStorageEnabled")
    def auto_scaling_for_storage_enabled(self) -> bool:
        """
        Indicates if auto scaling is enabled for the Autonomous Database storage.
        """
        return pulumi.get(self, "auto_scaling_for_storage_enabled")

    @property
    @pulumi.getter(name="autonomousDatabaseId")
    def autonomous_database_id(self) -> str:
        """
        The database [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
        """
        return pulumi.get(self, "autonomous_database_id")

    @property
    @pulumi.getter(name="availableUpgradeVersions")
    def available_upgrade_versions(self) -> Sequence[str]:
        """
        List of Oracle Database versions available for a database upgrade. If there are no version upgrades available, this list is empty.
        """
        return pulumi.get(self, "available_upgrade_versions")

    @property
    @pulumi.getter(name="backupRetentionPeriodInDays")
    def backup_retention_period_in_days(self) -> int:
        """
        Retention period, in days, for backups.
        """
        return pulumi.get(self, "backup_retention_period_in_days")

    @property
    @pulumi.getter(name="characterSet")
    def character_set(self) -> str:
        """
        The character set for the autonomous database.
        """
        return pulumi.get(self, "character_set")

    @property
    @pulumi.getter(name="computeCount")
    def compute_count(self) -> float:
        """
        The compute amount (CPUs) available to the database.
        """
        return pulumi.get(self, "compute_count")

    @property
    @pulumi.getter(name="cpuCoreCount")
    def cpu_core_count(self) -> int:
        """
        The number of CPU cores to be made available to the database. When the ECPU is selected, the value for cpuCoreCount is 0. For Autonomous Database on Dedicated Exadata infrastructure, the maximum number of cores is determined by the infrastructure shape. See [Characteristics of Infrastructure Shapes](https://www.oracle.com/pls/topic/lookup?ctx=en/cloud/paas/autonomous-database&id=ATPFG-GUID-B0F033C1-CC5A-42F0-B2E7-3CECFEDA1FD1) for shape details.
        """
        return pulumi.get(self, "cpu_core_count")

    @property
    @pulumi.getter(name="dataStorageSizeInGbs")
    def data_storage_size_in_gbs(self) -> int:
        """
        The quantity of data in the database, in gigabytes.
        """
        return pulumi.get(self, "data_storage_size_in_gbs")

    @property
    @pulumi.getter(name="dataStorageSizeInTbs")
    def data_storage_size_in_tbs(self) -> int:
        """
        The maximum storage that can be allocated for the database, in terabytes.
        """
        return pulumi.get(self, "data_storage_size_in_tbs")

    @property
    @pulumi.getter(name="dbNodeStorageSizeInGbs")
    def db_node_storage_size_in_gbs(self) -> int:
        """
        The DB node storage size in, in gigabytes.
        """
        return pulumi.get(self, "db_node_storage_size_in_gbs")

    @property
    @pulumi.getter(name="dbVersion")
    def db_version(self) -> str:
        """
        A valid Oracle Database version for Autonomous Database.
        """
        return pulumi.get(self, "db_version")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        The user-friendly name for the Autonomous Database. The name does not have to be unique.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="failedDataRecoveryInSeconds")
    def failed_data_recovery_in_seconds(self) -> int:
        """
        Indicates the number of seconds of data loss for a Data Guard failover.
        """
        return pulumi.get(self, "failed_data_recovery_in_seconds")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The provider-assigned unique ID for this managed resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="inMemoryAreaInGbs")
    def in_memory_area_in_gbs(self) -> int:
        """
        The area assigned to In-Memory tables in Autonomous Database.
        """
        return pulumi.get(self, "in_memory_area_in_gbs")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        Information about the current lifecycle state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="localAdgAutoFailoverMaxDataLossLimit")
    def local_adg_auto_failover_max_data_loss_limit(self) -> int:
        """
        Parameter that allows users to select an acceptable maximum data loss limit in seconds, up to which Automatic Failover will be triggered when necessary for a Local Autonomous Data Guard
        """
        return pulumi.get(self, "local_adg_auto_failover_max_data_loss_limit")

    @property
    @pulumi.getter(name="localDataGuardEnabled")
    def local_data_guard_enabled(self) -> bool:
        """
        Indicates whether the Autonomous Database has local (in-region) Data Guard enabled. Not applicable to cross-region Autonomous Data Guard associations, or to Autonomous Databases using dedicated Exadata infrastructure or Exadata Cloud@Customer infrastructure.
        """
        return pulumi.get(self, "local_data_guard_enabled")

    @property
    @pulumi.getter
    def location(self) -> str:
        """
        The Azure Region where the Autonomous Database exists.
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="memoryPerOracleComputeUnitInGbs")
    def memory_per_oracle_compute_unit_in_gbs(self) -> int:
        """
        The amount of memory (in GBs) enabled per ECPU or OCPU.
        """
        return pulumi.get(self, "memory_per_oracle_compute_unit_in_gbs")

    @property
    @pulumi.getter(name="mtlsConnectionRequired")
    def mtls_connection_required(self) -> bool:
        """
        Specifies if the Autonomous Database requires mTLS connections.
        """
        return pulumi.get(self, "mtls_connection_required")

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

    @property
    @pulumi.getter(name="nationalCharacterSet")
    def national_character_set(self) -> str:
        """
        The national character set for the autonomous database.  The default is AL16UTF16. Allowed values are: AL16UTF16 or UTF8.
        """
        return pulumi.get(self, "national_character_set")

    @property
    @pulumi.getter(name="nextLongTermBackupTimeStamp")
    def next_long_term_backup_time_stamp(self) -> str:
        """
        The date and time when the next long-term backup would be created.
        """
        return pulumi.get(self, "next_long_term_backup_time_stamp")

    @property
    @pulumi.getter(name="ociUrl")
    def oci_url(self) -> str:
        """
        The URL of the resource in the OCI console.
        """
        return pulumi.get(self, "oci_url")

    @property
    @pulumi.getter
    def ocid(self) -> str:
        """
        The [OCID](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/identifiers.htm) of the autonomous database.
        """
        return pulumi.get(self, "ocid")

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

    @property
    @pulumi.getter(name="peerDbIds")
    def peer_db_ids(self) -> Sequence[str]:
        """
        The list of [OCIDs](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of standby databases located in Autonomous Data Guard remote regions that are associated with the source database. Note that for Autonomous Database Serverless instances, standby databases located in the same region as the source primary database do not have OCIDs.
        """
        return pulumi.get(self, "peer_db_ids")

    @property
    @pulumi.getter
    def preview(self) -> bool:
        """
        Indicates if the Autonomous Database version is a preview version.
        """
        return pulumi.get(self, "preview")

    @property
    @pulumi.getter(name="previewVersionWithServiceTermsAccepted")
    def preview_version_with_service_terms_accepted(self) -> bool:
        """
        Indicates if the Autonomous Database version is a preview version with service terms accepted.
        """
        return pulumi.get(self, "preview_version_with_service_terms_accepted")

    @property
    @pulumi.getter(name="privateEndpoint")
    def private_endpoint(self) -> str:
        """
        The private endpoint for the resource.
        """
        return pulumi.get(self, "private_endpoint")

    @property
    @pulumi.getter(name="privateEndpointIp")
    def private_endpoint_ip(self) -> str:
        """
        The private endpoint Ip address for the resource.
        """
        return pulumi.get(self, "private_endpoint_ip")

    @property
    @pulumi.getter(name="privateEndpointLabel")
    def private_endpoint_label(self) -> str:
        """
        The private endpoint label for the resource.
        """
        return pulumi.get(self, "private_endpoint_label")

    @property
    @pulumi.getter(name="provisionableCpuses")
    def provisionable_cpuses(self) -> Sequence[int]:
        """
        An array of CPU values that an Autonomous Database can be scaled to.
        """
        return pulumi.get(self, "provisionable_cpuses")

    @property
    @pulumi.getter(name="remoteDataGuardEnabled")
    def remote_data_guard_enabled(self) -> bool:
        """
        Indicates whether the Autonomous Database has Cross Region Data Guard enabled. Not applicable to Autonomous Databases using dedicated Exadata infrastructure or Exadata Cloud@Customer infrastructure.
        """
        return pulumi.get(self, "remote_data_guard_enabled")

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

    @property
    @pulumi.getter(name="serviceConsoleUrl")
    def service_console_url(self) -> str:
        """
        The URL of the Service Console for the Autonomous Database.
        """
        return pulumi.get(self, "service_console_url")

    @property
    @pulumi.getter(name="sqlWebDeveloperUrl")
    def sql_web_developer_url(self) -> str:
        """
        The URL of the SQL web developer.
        """
        return pulumi.get(self, "sql_web_developer_url")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subnet the resource is associated with.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="supportedRegionsToCloneTos")
    def supported_regions_to_clone_tos(self) -> Sequence[int]:
        """
        The list of regions that support the creation of an Autonomous Database clone or an Autonomous Data Guard standby database.
        """
        return pulumi.get(self, "supported_regions_to_clone_tos")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, str]:
        """
        A mapping of tags assigned to the Autonomous Database.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the Autonomous Database was created.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeDataGuardRoleChanged")
    def time_data_guard_role_changed(self) -> str:
        """
        The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
        """
        return pulumi.get(self, "time_data_guard_role_changed")

    @property
    @pulumi.getter(name="timeDeletionOfFreeAutonomousDatabase")
    def time_deletion_of_free_autonomous_database(self) -> str:
        """
        The date and time the Always Free database will be automatically deleted because of inactivity. If the database is in the STOPPED state and without activity until this time, it will be deleted.
        """
        return pulumi.get(self, "time_deletion_of_free_autonomous_database")

    @property
    @pulumi.getter(name="timeLocalDataGuardEnabledOn")
    def time_local_data_guard_enabled_on(self) -> str:
        """
        The date and time that Autonomous Data Guard was enabled for an Autonomous Database where the standby was provisioned in the same region as the primary database.
        """
        return pulumi.get(self, "time_local_data_guard_enabled_on")

    @property
    @pulumi.getter(name="timeMaintenanceBegin")
    def time_maintenance_begin(self) -> str:
        """
        The date and time when maintenance will begin.
        """
        return pulumi.get(self, "time_maintenance_begin")

    @property
    @pulumi.getter(name="timeMaintenanceEnd")
    def time_maintenance_end(self) -> str:
        """
        The date and time when maintenance will end.
        """
        return pulumi.get(self, "time_maintenance_end")

    @property
    @pulumi.getter(name="timeOfLastFailover")
    def time_of_last_failover(self) -> str:
        """
        The timestamp of the last failover operation.
        """
        return pulumi.get(self, "time_of_last_failover")

    @property
    @pulumi.getter(name="timeOfLastRefresh")
    def time_of_last_refresh(self) -> str:
        """
        The date and time when last refresh happened.
        """
        return pulumi.get(self, "time_of_last_refresh")

    @property
    @pulumi.getter(name="timeOfLastRefreshPoint")
    def time_of_last_refresh_point(self) -> str:
        """
        The refresh point timestamp (UTC). The refresh point is the time to which the database was most recently refreshed. Data created after the refresh point is not included in the refresh.
        """
        return pulumi.get(self, "time_of_last_refresh_point")

    @property
    @pulumi.getter(name="timeOfLastSwitchover")
    def time_of_last_switchover(self) -> str:
        """
        The timestamp of the last switchover operation for the Autonomous Database.
        """
        return pulumi.get(self, "time_of_last_switchover")

    @property
    @pulumi.getter(name="timeReclamationOfFreeAutonomousDatabase")
    def time_reclamation_of_free_autonomous_database(self) -> str:
        """
        The date and time the Always Free database will be stopped because of inactivity. If this time is reached without any database activity, the database will automatically be put into the STOPPED state.
        """
        return pulumi.get(self, "time_reclamation_of_free_autonomous_database")

    @property
    @pulumi.getter(name="usedDataStorageSizeInGbs")
    def used_data_storage_size_in_gbs(self) -> int:
        """
        The storage space consumed by Autonomous Database in GBs.
        """
        return pulumi.get(self, "used_data_storage_size_in_gbs")

    @property
    @pulumi.getter(name="usedDataStorageSizeInTbs")
    def used_data_storage_size_in_tbs(self) -> int:
        """
        The amount of storage that has been used, in terabytes.
        """
        return pulumi.get(self, "used_data_storage_size_in_tbs")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> str:
        """
        The ID to an Azure Resource Manager vnet resource.
        """
        return pulumi.get(self, "virtual_network_id")


class AwaitableGetAutonomousDatabaseResult(GetAutonomousDatabaseResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetAutonomousDatabaseResult(
            actual_used_data_storage_size_in_tbs=self.actual_used_data_storage_size_in_tbs,
            allocated_storage_size_in_tbs=self.allocated_storage_size_in_tbs,
            allowed_ips=self.allowed_ips,
            auto_scaling_enabled=self.auto_scaling_enabled,
            auto_scaling_for_storage_enabled=self.auto_scaling_for_storage_enabled,
            autonomous_database_id=self.autonomous_database_id,
            available_upgrade_versions=self.available_upgrade_versions,
            backup_retention_period_in_days=self.backup_retention_period_in_days,
            character_set=self.character_set,
            compute_count=self.compute_count,
            cpu_core_count=self.cpu_core_count,
            data_storage_size_in_gbs=self.data_storage_size_in_gbs,
            data_storage_size_in_tbs=self.data_storage_size_in_tbs,
            db_node_storage_size_in_gbs=self.db_node_storage_size_in_gbs,
            db_version=self.db_version,
            display_name=self.display_name,
            failed_data_recovery_in_seconds=self.failed_data_recovery_in_seconds,
            id=self.id,
            in_memory_area_in_gbs=self.in_memory_area_in_gbs,
            lifecycle_details=self.lifecycle_details,
            local_adg_auto_failover_max_data_loss_limit=self.local_adg_auto_failover_max_data_loss_limit,
            local_data_guard_enabled=self.local_data_guard_enabled,
            location=self.location,
            memory_per_oracle_compute_unit_in_gbs=self.memory_per_oracle_compute_unit_in_gbs,
            mtls_connection_required=self.mtls_connection_required,
            name=self.name,
            national_character_set=self.national_character_set,
            next_long_term_backup_time_stamp=self.next_long_term_backup_time_stamp,
            oci_url=self.oci_url,
            ocid=self.ocid,
            peer_db_id=self.peer_db_id,
            peer_db_ids=self.peer_db_ids,
            preview=self.preview,
            preview_version_with_service_terms_accepted=self.preview_version_with_service_terms_accepted,
            private_endpoint=self.private_endpoint,
            private_endpoint_ip=self.private_endpoint_ip,
            private_endpoint_label=self.private_endpoint_label,
            provisionable_cpuses=self.provisionable_cpuses,
            remote_data_guard_enabled=self.remote_data_guard_enabled,
            resource_group_name=self.resource_group_name,
            service_console_url=self.service_console_url,
            sql_web_developer_url=self.sql_web_developer_url,
            subnet_id=self.subnet_id,
            supported_regions_to_clone_tos=self.supported_regions_to_clone_tos,
            tags=self.tags,
            time_created=self.time_created,
            time_data_guard_role_changed=self.time_data_guard_role_changed,
            time_deletion_of_free_autonomous_database=self.time_deletion_of_free_autonomous_database,
            time_local_data_guard_enabled_on=self.time_local_data_guard_enabled_on,
            time_maintenance_begin=self.time_maintenance_begin,
            time_maintenance_end=self.time_maintenance_end,
            time_of_last_failover=self.time_of_last_failover,
            time_of_last_refresh=self.time_of_last_refresh,
            time_of_last_refresh_point=self.time_of_last_refresh_point,
            time_of_last_switchover=self.time_of_last_switchover,
            time_reclamation_of_free_autonomous_database=self.time_reclamation_of_free_autonomous_database,
            used_data_storage_size_in_gbs=self.used_data_storage_size_in_gbs,
            used_data_storage_size_in_tbs=self.used_data_storage_size_in_tbs,
            virtual_network_id=self.virtual_network_id)


def get_autonomous_database(name: Optional[str] = None,
                            resource_group_name: Optional[str] = None,
                            opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAutonomousDatabaseResult:
    """
    Use this data source to access information about an existing Autonomous Database.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_azure as azure

    example = azure.oracle.get_autonomous_database(name="existing",
        resource_group_name="existing")
    pulumi.export("id", example.id)
    ```


    :param str name: The name of this Autonomous Database.
    :param str resource_group_name: The name of the Resource Group where the Autonomous Database exists.
    """
    __args__ = dict()
    __args__['name'] = name
    __args__['resourceGroupName'] = resource_group_name
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('azure:oracle/getAutonomousDatabase:getAutonomousDatabase', __args__, opts=opts, typ=GetAutonomousDatabaseResult).value

    return AwaitableGetAutonomousDatabaseResult(
        actual_used_data_storage_size_in_tbs=pulumi.get(__ret__, 'actual_used_data_storage_size_in_tbs'),
        allocated_storage_size_in_tbs=pulumi.get(__ret__, 'allocated_storage_size_in_tbs'),
        allowed_ips=pulumi.get(__ret__, 'allowed_ips'),
        auto_scaling_enabled=pulumi.get(__ret__, 'auto_scaling_enabled'),
        auto_scaling_for_storage_enabled=pulumi.get(__ret__, 'auto_scaling_for_storage_enabled'),
        autonomous_database_id=pulumi.get(__ret__, 'autonomous_database_id'),
        available_upgrade_versions=pulumi.get(__ret__, 'available_upgrade_versions'),
        backup_retention_period_in_days=pulumi.get(__ret__, 'backup_retention_period_in_days'),
        character_set=pulumi.get(__ret__, 'character_set'),
        compute_count=pulumi.get(__ret__, 'compute_count'),
        cpu_core_count=pulumi.get(__ret__, 'cpu_core_count'),
        data_storage_size_in_gbs=pulumi.get(__ret__, 'data_storage_size_in_gbs'),
        data_storage_size_in_tbs=pulumi.get(__ret__, 'data_storage_size_in_tbs'),
        db_node_storage_size_in_gbs=pulumi.get(__ret__, 'db_node_storage_size_in_gbs'),
        db_version=pulumi.get(__ret__, 'db_version'),
        display_name=pulumi.get(__ret__, 'display_name'),
        failed_data_recovery_in_seconds=pulumi.get(__ret__, 'failed_data_recovery_in_seconds'),
        id=pulumi.get(__ret__, 'id'),
        in_memory_area_in_gbs=pulumi.get(__ret__, 'in_memory_area_in_gbs'),
        lifecycle_details=pulumi.get(__ret__, 'lifecycle_details'),
        local_adg_auto_failover_max_data_loss_limit=pulumi.get(__ret__, 'local_adg_auto_failover_max_data_loss_limit'),
        local_data_guard_enabled=pulumi.get(__ret__, 'local_data_guard_enabled'),
        location=pulumi.get(__ret__, 'location'),
        memory_per_oracle_compute_unit_in_gbs=pulumi.get(__ret__, 'memory_per_oracle_compute_unit_in_gbs'),
        mtls_connection_required=pulumi.get(__ret__, 'mtls_connection_required'),
        name=pulumi.get(__ret__, 'name'),
        national_character_set=pulumi.get(__ret__, 'national_character_set'),
        next_long_term_backup_time_stamp=pulumi.get(__ret__, 'next_long_term_backup_time_stamp'),
        oci_url=pulumi.get(__ret__, 'oci_url'),
        ocid=pulumi.get(__ret__, 'ocid'),
        peer_db_id=pulumi.get(__ret__, 'peer_db_id'),
        peer_db_ids=pulumi.get(__ret__, 'peer_db_ids'),
        preview=pulumi.get(__ret__, 'preview'),
        preview_version_with_service_terms_accepted=pulumi.get(__ret__, 'preview_version_with_service_terms_accepted'),
        private_endpoint=pulumi.get(__ret__, 'private_endpoint'),
        private_endpoint_ip=pulumi.get(__ret__, 'private_endpoint_ip'),
        private_endpoint_label=pulumi.get(__ret__, 'private_endpoint_label'),
        provisionable_cpuses=pulumi.get(__ret__, 'provisionable_cpuses'),
        remote_data_guard_enabled=pulumi.get(__ret__, 'remote_data_guard_enabled'),
        resource_group_name=pulumi.get(__ret__, 'resource_group_name'),
        service_console_url=pulumi.get(__ret__, 'service_console_url'),
        sql_web_developer_url=pulumi.get(__ret__, 'sql_web_developer_url'),
        subnet_id=pulumi.get(__ret__, 'subnet_id'),
        supported_regions_to_clone_tos=pulumi.get(__ret__, 'supported_regions_to_clone_tos'),
        tags=pulumi.get(__ret__, 'tags'),
        time_created=pulumi.get(__ret__, 'time_created'),
        time_data_guard_role_changed=pulumi.get(__ret__, 'time_data_guard_role_changed'),
        time_deletion_of_free_autonomous_database=pulumi.get(__ret__, 'time_deletion_of_free_autonomous_database'),
        time_local_data_guard_enabled_on=pulumi.get(__ret__, 'time_local_data_guard_enabled_on'),
        time_maintenance_begin=pulumi.get(__ret__, 'time_maintenance_begin'),
        time_maintenance_end=pulumi.get(__ret__, 'time_maintenance_end'),
        time_of_last_failover=pulumi.get(__ret__, 'time_of_last_failover'),
        time_of_last_refresh=pulumi.get(__ret__, 'time_of_last_refresh'),
        time_of_last_refresh_point=pulumi.get(__ret__, 'time_of_last_refresh_point'),
        time_of_last_switchover=pulumi.get(__ret__, 'time_of_last_switchover'),
        time_reclamation_of_free_autonomous_database=pulumi.get(__ret__, 'time_reclamation_of_free_autonomous_database'),
        used_data_storage_size_in_gbs=pulumi.get(__ret__, 'used_data_storage_size_in_gbs'),
        used_data_storage_size_in_tbs=pulumi.get(__ret__, 'used_data_storage_size_in_tbs'),
        virtual_network_id=pulumi.get(__ret__, 'virtual_network_id'))
def get_autonomous_database_output(name: Optional[pulumi.Input[str]] = None,
                                   resource_group_name: Optional[pulumi.Input[str]] = None,
                                   opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetAutonomousDatabaseResult]:
    """
    Use this data source to access information about an existing Autonomous Database.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_azure as azure

    example = azure.oracle.get_autonomous_database(name="existing",
        resource_group_name="existing")
    pulumi.export("id", example.id)
    ```


    :param str name: The name of this Autonomous Database.
    :param str resource_group_name: The name of the Resource Group where the Autonomous Database exists.
    """
    __args__ = dict()
    __args__['name'] = name
    __args__['resourceGroupName'] = resource_group_name
    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke_output('azure:oracle/getAutonomousDatabase:getAutonomousDatabase', __args__, opts=opts, typ=GetAutonomousDatabaseResult)
    return __ret__.apply(lambda __response__: GetAutonomousDatabaseResult(
        actual_used_data_storage_size_in_tbs=pulumi.get(__response__, 'actual_used_data_storage_size_in_tbs'),
        allocated_storage_size_in_tbs=pulumi.get(__response__, 'allocated_storage_size_in_tbs'),
        allowed_ips=pulumi.get(__response__, 'allowed_ips'),
        auto_scaling_enabled=pulumi.get(__response__, 'auto_scaling_enabled'),
        auto_scaling_for_storage_enabled=pulumi.get(__response__, 'auto_scaling_for_storage_enabled'),
        autonomous_database_id=pulumi.get(__response__, 'autonomous_database_id'),
        available_upgrade_versions=pulumi.get(__response__, 'available_upgrade_versions'),
        backup_retention_period_in_days=pulumi.get(__response__, 'backup_retention_period_in_days'),
        character_set=pulumi.get(__response__, 'character_set'),
        compute_count=pulumi.get(__response__, 'compute_count'),
        cpu_core_count=pulumi.get(__response__, 'cpu_core_count'),
        data_storage_size_in_gbs=pulumi.get(__response__, 'data_storage_size_in_gbs'),
        data_storage_size_in_tbs=pulumi.get(__response__, 'data_storage_size_in_tbs'),
        db_node_storage_size_in_gbs=pulumi.get(__response__, 'db_node_storage_size_in_gbs'),
        db_version=pulumi.get(__response__, 'db_version'),
        display_name=pulumi.get(__response__, 'display_name'),
        failed_data_recovery_in_seconds=pulumi.get(__response__, 'failed_data_recovery_in_seconds'),
        id=pulumi.get(__response__, 'id'),
        in_memory_area_in_gbs=pulumi.get(__response__, 'in_memory_area_in_gbs'),
        lifecycle_details=pulumi.get(__response__, 'lifecycle_details'),
        local_adg_auto_failover_max_data_loss_limit=pulumi.get(__response__, 'local_adg_auto_failover_max_data_loss_limit'),
        local_data_guard_enabled=pulumi.get(__response__, 'local_data_guard_enabled'),
        location=pulumi.get(__response__, 'location'),
        memory_per_oracle_compute_unit_in_gbs=pulumi.get(__response__, 'memory_per_oracle_compute_unit_in_gbs'),
        mtls_connection_required=pulumi.get(__response__, 'mtls_connection_required'),
        name=pulumi.get(__response__, 'name'),
        national_character_set=pulumi.get(__response__, 'national_character_set'),
        next_long_term_backup_time_stamp=pulumi.get(__response__, 'next_long_term_backup_time_stamp'),
        oci_url=pulumi.get(__response__, 'oci_url'),
        ocid=pulumi.get(__response__, 'ocid'),
        peer_db_id=pulumi.get(__response__, 'peer_db_id'),
        peer_db_ids=pulumi.get(__response__, 'peer_db_ids'),
        preview=pulumi.get(__response__, 'preview'),
        preview_version_with_service_terms_accepted=pulumi.get(__response__, 'preview_version_with_service_terms_accepted'),
        private_endpoint=pulumi.get(__response__, 'private_endpoint'),
        private_endpoint_ip=pulumi.get(__response__, 'private_endpoint_ip'),
        private_endpoint_label=pulumi.get(__response__, 'private_endpoint_label'),
        provisionable_cpuses=pulumi.get(__response__, 'provisionable_cpuses'),
        remote_data_guard_enabled=pulumi.get(__response__, 'remote_data_guard_enabled'),
        resource_group_name=pulumi.get(__response__, 'resource_group_name'),
        service_console_url=pulumi.get(__response__, 'service_console_url'),
        sql_web_developer_url=pulumi.get(__response__, 'sql_web_developer_url'),
        subnet_id=pulumi.get(__response__, 'subnet_id'),
        supported_regions_to_clone_tos=pulumi.get(__response__, 'supported_regions_to_clone_tos'),
        tags=pulumi.get(__response__, 'tags'),
        time_created=pulumi.get(__response__, 'time_created'),
        time_data_guard_role_changed=pulumi.get(__response__, 'time_data_guard_role_changed'),
        time_deletion_of_free_autonomous_database=pulumi.get(__response__, 'time_deletion_of_free_autonomous_database'),
        time_local_data_guard_enabled_on=pulumi.get(__response__, 'time_local_data_guard_enabled_on'),
        time_maintenance_begin=pulumi.get(__response__, 'time_maintenance_begin'),
        time_maintenance_end=pulumi.get(__response__, 'time_maintenance_end'),
        time_of_last_failover=pulumi.get(__response__, 'time_of_last_failover'),
        time_of_last_refresh=pulumi.get(__response__, 'time_of_last_refresh'),
        time_of_last_refresh_point=pulumi.get(__response__, 'time_of_last_refresh_point'),
        time_of_last_switchover=pulumi.get(__response__, 'time_of_last_switchover'),
        time_reclamation_of_free_autonomous_database=pulumi.get(__response__, 'time_reclamation_of_free_autonomous_database'),
        used_data_storage_size_in_gbs=pulumi.get(__response__, 'used_data_storage_size_in_gbs'),
        used_data_storage_size_in_tbs=pulumi.get(__response__, 'used_data_storage_size_in_tbs'),
        virtual_network_id=pulumi.get(__response__, 'virtual_network_id')))
