# 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
from . import outputs

__all__ = [
    'GetConnectionResult',
    'AwaitableGetConnectionResult',
    'get_connection',
    'get_connection_output',
]

@pulumi.output_type
class GetConnectionResult:
    """
    A collection of values returned by getConnection.
    """
    def __init__(__self__, access_key_id=None, account_key=None, account_name=None, additional_attributes=None, authentication_type=None, azure_tenant_id=None, bootstrap_servers=None, client_id=None, client_secret=None, compartment_id=None, connection_factory=None, connection_id=None, connection_string=None, connection_type=None, connection_url=None, consumer_properties=None, core_site_xml=None, database_id=None, database_name=None, db_system_id=None, defined_tags=None, deployment_id=None, description=None, display_name=None, endpoint=None, freeform_tags=None, host=None, id=None, ingress_ips=None, jndi_connection_factory=None, jndi_initial_context_factory=None, jndi_provider_url=None, jndi_security_credentials=None, jndi_security_principal=None, key_id=None, key_store=None, key_store_password=None, lifecycle_details=None, nsg_ids=None, password=None, port=None, private_ip=None, private_key_file=None, private_key_passphrase=None, producer_properties=None, public_key_fingerprint=None, region=None, sas_token=None, secret_access_key=None, security_protocol=None, session_mode=None, should_use_jndi=None, should_validate_server_certificate=None, ssl_ca=None, ssl_cert=None, ssl_crl=None, ssl_key=None, ssl_key_password=None, ssl_mode=None, state=None, stream_pool_id=None, subnet_id=None, system_tags=None, technology_type=None, tenancy_id=None, time_created=None, time_updated=None, trust_store=None, trust_store_password=None, url=None, user_id=None, username=None, vault_id=None, wallet=None):
        if access_key_id and not isinstance(access_key_id, str):
            raise TypeError("Expected argument 'access_key_id' to be a str")
        pulumi.set(__self__, "access_key_id", access_key_id)
        if account_key and not isinstance(account_key, str):
            raise TypeError("Expected argument 'account_key' to be a str")
        pulumi.set(__self__, "account_key", account_key)
        if account_name and not isinstance(account_name, str):
            raise TypeError("Expected argument 'account_name' to be a str")
        pulumi.set(__self__, "account_name", account_name)
        if additional_attributes and not isinstance(additional_attributes, list):
            raise TypeError("Expected argument 'additional_attributes' to be a list")
        pulumi.set(__self__, "additional_attributes", additional_attributes)
        if authentication_type and not isinstance(authentication_type, str):
            raise TypeError("Expected argument 'authentication_type' to be a str")
        pulumi.set(__self__, "authentication_type", authentication_type)
        if azure_tenant_id and not isinstance(azure_tenant_id, str):
            raise TypeError("Expected argument 'azure_tenant_id' to be a str")
        pulumi.set(__self__, "azure_tenant_id", azure_tenant_id)
        if bootstrap_servers and not isinstance(bootstrap_servers, list):
            raise TypeError("Expected argument 'bootstrap_servers' to be a list")
        pulumi.set(__self__, "bootstrap_servers", bootstrap_servers)
        if client_id and not isinstance(client_id, str):
            raise TypeError("Expected argument 'client_id' to be a str")
        pulumi.set(__self__, "client_id", client_id)
        if client_secret and not isinstance(client_secret, str):
            raise TypeError("Expected argument 'client_secret' to be a str")
        pulumi.set(__self__, "client_secret", client_secret)
        if compartment_id and not isinstance(compartment_id, str):
            raise TypeError("Expected argument 'compartment_id' to be a str")
        pulumi.set(__self__, "compartment_id", compartment_id)
        if connection_factory and not isinstance(connection_factory, str):
            raise TypeError("Expected argument 'connection_factory' to be a str")
        pulumi.set(__self__, "connection_factory", connection_factory)
        if connection_id and not isinstance(connection_id, str):
            raise TypeError("Expected argument 'connection_id' to be a str")
        pulumi.set(__self__, "connection_id", connection_id)
        if connection_string and not isinstance(connection_string, str):
            raise TypeError("Expected argument 'connection_string' to be a str")
        pulumi.set(__self__, "connection_string", connection_string)
        if connection_type and not isinstance(connection_type, str):
            raise TypeError("Expected argument 'connection_type' to be a str")
        pulumi.set(__self__, "connection_type", connection_type)
        if connection_url and not isinstance(connection_url, str):
            raise TypeError("Expected argument 'connection_url' to be a str")
        pulumi.set(__self__, "connection_url", connection_url)
        if consumer_properties and not isinstance(consumer_properties, str):
            raise TypeError("Expected argument 'consumer_properties' to be a str")
        pulumi.set(__self__, "consumer_properties", consumer_properties)
        if core_site_xml and not isinstance(core_site_xml, str):
            raise TypeError("Expected argument 'core_site_xml' to be a str")
        pulumi.set(__self__, "core_site_xml", core_site_xml)
        if database_id and not isinstance(database_id, str):
            raise TypeError("Expected argument 'database_id' to be a str")
        pulumi.set(__self__, "database_id", database_id)
        if database_name and not isinstance(database_name, str):
            raise TypeError("Expected argument 'database_name' to be a str")
        pulumi.set(__self__, "database_name", database_name)
        if db_system_id and not isinstance(db_system_id, str):
            raise TypeError("Expected argument 'db_system_id' to be a str")
        pulumi.set(__self__, "db_system_id", db_system_id)
        if defined_tags and not isinstance(defined_tags, dict):
            raise TypeError("Expected argument 'defined_tags' to be a dict")
        pulumi.set(__self__, "defined_tags", defined_tags)
        if deployment_id and not isinstance(deployment_id, str):
            raise TypeError("Expected argument 'deployment_id' to be a str")
        pulumi.set(__self__, "deployment_id", deployment_id)
        if description and not isinstance(description, str):
            raise TypeError("Expected argument 'description' to be a str")
        pulumi.set(__self__, "description", description)
        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 endpoint and not isinstance(endpoint, str):
            raise TypeError("Expected argument 'endpoint' to be a str")
        pulumi.set(__self__, "endpoint", endpoint)
        if freeform_tags and not isinstance(freeform_tags, dict):
            raise TypeError("Expected argument 'freeform_tags' to be a dict")
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        if host and not isinstance(host, str):
            raise TypeError("Expected argument 'host' to be a str")
        pulumi.set(__self__, "host", host)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if ingress_ips and not isinstance(ingress_ips, list):
            raise TypeError("Expected argument 'ingress_ips' to be a list")
        pulumi.set(__self__, "ingress_ips", ingress_ips)
        if jndi_connection_factory and not isinstance(jndi_connection_factory, str):
            raise TypeError("Expected argument 'jndi_connection_factory' to be a str")
        pulumi.set(__self__, "jndi_connection_factory", jndi_connection_factory)
        if jndi_initial_context_factory and not isinstance(jndi_initial_context_factory, str):
            raise TypeError("Expected argument 'jndi_initial_context_factory' to be a str")
        pulumi.set(__self__, "jndi_initial_context_factory", jndi_initial_context_factory)
        if jndi_provider_url and not isinstance(jndi_provider_url, str):
            raise TypeError("Expected argument 'jndi_provider_url' to be a str")
        pulumi.set(__self__, "jndi_provider_url", jndi_provider_url)
        if jndi_security_credentials and not isinstance(jndi_security_credentials, str):
            raise TypeError("Expected argument 'jndi_security_credentials' to be a str")
        pulumi.set(__self__, "jndi_security_credentials", jndi_security_credentials)
        if jndi_security_principal and not isinstance(jndi_security_principal, str):
            raise TypeError("Expected argument 'jndi_security_principal' to be a str")
        pulumi.set(__self__, "jndi_security_principal", jndi_security_principal)
        if key_id and not isinstance(key_id, str):
            raise TypeError("Expected argument 'key_id' to be a str")
        pulumi.set(__self__, "key_id", key_id)
        if key_store and not isinstance(key_store, str):
            raise TypeError("Expected argument 'key_store' to be a str")
        pulumi.set(__self__, "key_store", key_store)
        if key_store_password and not isinstance(key_store_password, str):
            raise TypeError("Expected argument 'key_store_password' to be a str")
        pulumi.set(__self__, "key_store_password", key_store_password)
        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 nsg_ids and not isinstance(nsg_ids, list):
            raise TypeError("Expected argument 'nsg_ids' to be a list")
        pulumi.set(__self__, "nsg_ids", nsg_ids)
        if password and not isinstance(password, str):
            raise TypeError("Expected argument 'password' to be a str")
        pulumi.set(__self__, "password", password)
        if port and not isinstance(port, int):
            raise TypeError("Expected argument 'port' to be a int")
        pulumi.set(__self__, "port", port)
        if private_ip and not isinstance(private_ip, str):
            raise TypeError("Expected argument 'private_ip' to be a str")
        pulumi.set(__self__, "private_ip", private_ip)
        if private_key_file and not isinstance(private_key_file, str):
            raise TypeError("Expected argument 'private_key_file' to be a str")
        pulumi.set(__self__, "private_key_file", private_key_file)
        if private_key_passphrase and not isinstance(private_key_passphrase, str):
            raise TypeError("Expected argument 'private_key_passphrase' to be a str")
        pulumi.set(__self__, "private_key_passphrase", private_key_passphrase)
        if producer_properties and not isinstance(producer_properties, str):
            raise TypeError("Expected argument 'producer_properties' to be a str")
        pulumi.set(__self__, "producer_properties", producer_properties)
        if public_key_fingerprint and not isinstance(public_key_fingerprint, str):
            raise TypeError("Expected argument 'public_key_fingerprint' to be a str")
        pulumi.set(__self__, "public_key_fingerprint", public_key_fingerprint)
        if region and not isinstance(region, str):
            raise TypeError("Expected argument 'region' to be a str")
        pulumi.set(__self__, "region", region)
        if sas_token and not isinstance(sas_token, str):
            raise TypeError("Expected argument 'sas_token' to be a str")
        pulumi.set(__self__, "sas_token", sas_token)
        if secret_access_key and not isinstance(secret_access_key, str):
            raise TypeError("Expected argument 'secret_access_key' to be a str")
        pulumi.set(__self__, "secret_access_key", secret_access_key)
        if security_protocol and not isinstance(security_protocol, str):
            raise TypeError("Expected argument 'security_protocol' to be a str")
        pulumi.set(__self__, "security_protocol", security_protocol)
        if session_mode and not isinstance(session_mode, str):
            raise TypeError("Expected argument 'session_mode' to be a str")
        pulumi.set(__self__, "session_mode", session_mode)
        if should_use_jndi and not isinstance(should_use_jndi, bool):
            raise TypeError("Expected argument 'should_use_jndi' to be a bool")
        pulumi.set(__self__, "should_use_jndi", should_use_jndi)
        if should_validate_server_certificate and not isinstance(should_validate_server_certificate, bool):
            raise TypeError("Expected argument 'should_validate_server_certificate' to be a bool")
        pulumi.set(__self__, "should_validate_server_certificate", should_validate_server_certificate)
        if ssl_ca and not isinstance(ssl_ca, str):
            raise TypeError("Expected argument 'ssl_ca' to be a str")
        pulumi.set(__self__, "ssl_ca", ssl_ca)
        if ssl_cert and not isinstance(ssl_cert, str):
            raise TypeError("Expected argument 'ssl_cert' to be a str")
        pulumi.set(__self__, "ssl_cert", ssl_cert)
        if ssl_crl and not isinstance(ssl_crl, str):
            raise TypeError("Expected argument 'ssl_crl' to be a str")
        pulumi.set(__self__, "ssl_crl", ssl_crl)
        if ssl_key and not isinstance(ssl_key, str):
            raise TypeError("Expected argument 'ssl_key' to be a str")
        pulumi.set(__self__, "ssl_key", ssl_key)
        if ssl_key_password and not isinstance(ssl_key_password, str):
            raise TypeError("Expected argument 'ssl_key_password' to be a str")
        pulumi.set(__self__, "ssl_key_password", ssl_key_password)
        if ssl_mode and not isinstance(ssl_mode, str):
            raise TypeError("Expected argument 'ssl_mode' to be a str")
        pulumi.set(__self__, "ssl_mode", ssl_mode)
        if state and not isinstance(state, str):
            raise TypeError("Expected argument 'state' to be a str")
        pulumi.set(__self__, "state", state)
        if stream_pool_id and not isinstance(stream_pool_id, str):
            raise TypeError("Expected argument 'stream_pool_id' to be a str")
        pulumi.set(__self__, "stream_pool_id", stream_pool_id)
        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 system_tags and not isinstance(system_tags, dict):
            raise TypeError("Expected argument 'system_tags' to be a dict")
        pulumi.set(__self__, "system_tags", system_tags)
        if technology_type and not isinstance(technology_type, str):
            raise TypeError("Expected argument 'technology_type' to be a str")
        pulumi.set(__self__, "technology_type", technology_type)
        if tenancy_id and not isinstance(tenancy_id, str):
            raise TypeError("Expected argument 'tenancy_id' to be a str")
        pulumi.set(__self__, "tenancy_id", tenancy_id)
        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_updated and not isinstance(time_updated, str):
            raise TypeError("Expected argument 'time_updated' to be a str")
        pulumi.set(__self__, "time_updated", time_updated)
        if trust_store and not isinstance(trust_store, str):
            raise TypeError("Expected argument 'trust_store' to be a str")
        pulumi.set(__self__, "trust_store", trust_store)
        if trust_store_password and not isinstance(trust_store_password, str):
            raise TypeError("Expected argument 'trust_store_password' to be a str")
        pulumi.set(__self__, "trust_store_password", trust_store_password)
        if url and not isinstance(url, str):
            raise TypeError("Expected argument 'url' to be a str")
        pulumi.set(__self__, "url", url)
        if user_id and not isinstance(user_id, str):
            raise TypeError("Expected argument 'user_id' to be a str")
        pulumi.set(__self__, "user_id", user_id)
        if username and not isinstance(username, str):
            raise TypeError("Expected argument 'username' to be a str")
        pulumi.set(__self__, "username", username)
        if vault_id and not isinstance(vault_id, str):
            raise TypeError("Expected argument 'vault_id' to be a str")
        pulumi.set(__self__, "vault_id", vault_id)
        if wallet and not isinstance(wallet, str):
            raise TypeError("Expected argument 'wallet' to be a str")
        pulumi.set(__self__, "wallet", wallet)

    @property
    @pulumi.getter(name="accessKeyId")
    def access_key_id(self) -> str:
        """
        Access key ID to access the Amazon S3 bucket. e.g.: "this-is-not-the-secret"
        """
        return pulumi.get(self, "access_key_id")

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

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> str:
        """
        Sets the Azure storage account name.
        """
        return pulumi.get(self, "account_name")

    @property
    @pulumi.getter(name="additionalAttributes")
    def additional_attributes(self) -> Sequence['outputs.GetConnectionAdditionalAttributeResult']:
        """
        An array of name-value pair attribute entries. Used as additional parameters in connection string.
        """
        return pulumi.get(self, "additional_attributes")

    @property
    @pulumi.getter(name="authenticationType")
    def authentication_type(self) -> str:
        """
        Used authentication mechanism to access Azure Data Lake Storage.
        """
        return pulumi.get(self, "authentication_type")

    @property
    @pulumi.getter(name="azureTenantId")
    def azure_tenant_id(self) -> str:
        """
        Azure tenant ID of the application. This property is required when 'authenticationType' is set to 'AZURE_ACTIVE_DIRECTORY'. e.g.: 14593954-d337-4a61-a364-9f758c64f97f
        """
        return pulumi.get(self, "azure_tenant_id")

    @property
    @pulumi.getter(name="bootstrapServers")
    def bootstrap_servers(self) -> Sequence['outputs.GetConnectionBootstrapServerResult']:
        """
        Kafka bootstrap. Equivalent of bootstrap.servers configuration property in Kafka: list of KafkaBootstrapServer objects specified by host/port. Used for establishing the initial connection to the Kafka cluster. Example: `"server1.example.com:9092,server2.example.com:9092"`
        """
        return pulumi.get(self, "bootstrap_servers")

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        Azure client ID of the application. This property is required when 'authenticationType' is set to 'AZURE_ACTIVE_DIRECTORY'. e.g.: 06ecaabf-8b80-4ec8-a0ec-20cbf463703d
        """
        return pulumi.get(self, "client_id")

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

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment being referenced.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="connectionFactory")
    def connection_factory(self) -> str:
        """
        The of Java class implementing javax.jms.ConnectionFactory interface supplied by the Java Message Service provider. e.g.: 'com.stc.jmsjca.core.JConnectionFactoryXA'
        """
        return pulumi.get(self, "connection_factory")

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

    @property
    @pulumi.getter(name="connectionString")
    def connection_string(self) -> str:
        """
        Connection string. AZURE_SYNAPSE_ANALYTICS e.g.: 'jdbc:sqlserver://<synapse-workspace>.sql.azuresynapse.net:1433;database=<db-name>;encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.sql.azuresynapse.net;loginTimeout=300;', MONGODB e.g.: 'mongodb://mongodb0.example.com:27017/recordsrecords'.
        """
        return pulumi.get(self, "connection_string")

    @property
    @pulumi.getter(name="connectionType")
    def connection_type(self) -> str:
        """
        The connection type.
        """
        return pulumi.get(self, "connection_type")

    @property
    @pulumi.getter(name="connectionUrl")
    def connection_url(self) -> str:
        """
        JAVA_MESSAGE_SERVICE: Connection URL of the Java Message Service, specifying the protocol, host, and port. e.g.: 'mq://myjms.host.domain:7676', SNOWFLAKE: JDBC connection URL. e.g.: 'jdbc:snowflake://<account_name>.snowflakecomputing.com/?warehouse=<warehouse-name>&db=<db-name>'
        """
        return pulumi.get(self, "connection_url")

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

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

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The name of the database.
        """
        return pulumi.get(self, "database_name")

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

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Mapping[str, Any]:
        """
        Tags defined for this resource. Each key is predefined and scoped to a namespace.  Example: `{"foo-namespace.bar-key": "value"}`
        """
        return pulumi.get(self, "defined_tags")

    @property
    @pulumi.getter(name="deploymentId")
    def deployment_id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the deployment being referenced.
        """
        return pulumi.get(self, "deployment_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Metadata about this specific object.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        An object's Display Name.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        Azure Storage service endpoint. e.g: https://test.blob.core.windows.net
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Mapping[str, Any]:
        """
        A simple key-value pair that is applied without any predefined name, type, or scope. Exists for cross-compatibility only.  Example: `{"bar-key": "value"}`
        """
        return pulumi.get(self, "freeform_tags")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        The name or address of a host.
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the connection being referenced.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ingressIps")
    def ingress_ips(self) -> Sequence['outputs.GetConnectionIngressIpResult']:
        """
        List of ingress IP addresses from where the GoldenGate deployment connects to this connection's privateIp.  Customers may optionally set up ingress security rules to restrict traffic from these IP addresses.
        """
        return pulumi.get(self, "ingress_ips")

    @property
    @pulumi.getter(name="jndiConnectionFactory")
    def jndi_connection_factory(self) -> str:
        """
        The Connection Factory can be looked up using this name. e.g.: 'ConnectionFactory'
        """
        return pulumi.get(self, "jndi_connection_factory")

    @property
    @pulumi.getter(name="jndiInitialContextFactory")
    def jndi_initial_context_factory(self) -> str:
        """
        The implementation of javax.naming.spi.InitialContextFactory interface that the client uses to obtain initial naming context. e.g.: 'org.apache.activemq.jndi.ActiveMQInitialContextFactory'
        """
        return pulumi.get(self, "jndi_initial_context_factory")

    @property
    @pulumi.getter(name="jndiProviderUrl")
    def jndi_provider_url(self) -> str:
        """
        The URL that Java Message Service will use to contact the JNDI provider. e.g.: 'tcp://myjms.host.domain:61616?jms.prefetchPolicy.all=1000'
        """
        return pulumi.get(self, "jndi_provider_url")

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

    @property
    @pulumi.getter(name="jndiSecurityPrincipal")
    def jndi_security_principal(self) -> str:
        """
        Specifies the identity of the principal (user) to be authenticated. e.g.: 'admin2'
        """
        return pulumi.get(self, "jndi_security_principal")

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> str:
        """
        Refers to the customer's master key OCID.  If provided, it references a key to manage secrets. Customers must add policies to permit GoldenGate to use this key.
        """
        return pulumi.get(self, "key_id")

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

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

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        Describes the object's current state in detail. For example, it can be used to provide actionable information for a resource in a Failed state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter(name="nsgIds")
    def nsg_ids(self) -> Sequence[str]:
        """
        An array of Network Security Group OCIDs used to define network access for either Deployments or Connections.
        """
        return pulumi.get(self, "nsg_ids")

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

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port of an endpoint usually specified for a connection.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> str:
        """
        The private IP address of the connection's endpoint in the customer's VCN, typically a database endpoint or a big data endpoint (e.g. Kafka bootstrap server). In case the privateIp is provided, the subnetId must also be provided. In case the privateIp (and the subnetId) is not provided it is assumed the datasource is publicly accessible. In case the connection is accessible only privately, the lack of privateIp will result in not being able to access the connection.
        """
        return pulumi.get(self, "private_ip")

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

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

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

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

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        The name of the region. e.g.: us-ashburn-1
        """
        return pulumi.get(self, "region")

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

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

    @property
    @pulumi.getter(name="securityProtocol")
    def security_protocol(self) -> str:
        """
        Security Protocol for Microsoft SQL Server/PostgreSQL.
        """
        return pulumi.get(self, "security_protocol")

    @property
    @pulumi.getter(name="sessionMode")
    def session_mode(self) -> str:
        """
        The mode of the database connection session to be established by the data client. 'REDIRECT' - for a RAC database, 'DIRECT' - for a non-RAC database. Connection to a RAC database involves a redirection received from the SCAN listeners to the database node to connect to. By default the mode would be DIRECT.
        """
        return pulumi.get(self, "session_mode")

    @property
    @pulumi.getter(name="shouldUseJndi")
    def should_use_jndi(self) -> bool:
        """
        If set to true, Java Naming and Directory Interface (JNDI) properties should be provided.
        """
        return pulumi.get(self, "should_use_jndi")

    @property
    @pulumi.getter(name="shouldValidateServerCertificate")
    def should_validate_server_certificate(self) -> bool:
        """
        If set to true, the driver validates the certificate that is sent by the database server.
        """
        return pulumi.get(self, "should_validate_server_certificate")

    @property
    @pulumi.getter(name="sslCa")
    def ssl_ca(self) -> str:
        """
        Database Certificate - The base64 encoded content of pem file containing the server public key (for 1-way SSL).
        """
        return pulumi.get(self, "ssl_ca")

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

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

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

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

    @property
    @pulumi.getter(name="sslMode")
    def ssl_mode(self) -> str:
        """
        SSL mode for PostgreSQL.
        """
        return pulumi.get(self, "ssl_mode")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        Possible lifecycle states for connection.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="streamPoolId")
    def stream_pool_id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the stream pool being referenced.
        """
        return pulumi.get(self, "stream_pool_id")

    @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 being referenced.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="systemTags")
    def system_tags(self) -> Mapping[str, Any]:
        """
        The system tags associated with this resource, if any. The system tags are set by Oracle Cloud Infrastructure services. Each key is predefined and scoped to namespaces.  For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{orcl-cloud: {free-tier-retain: true}}`
        """
        return pulumi.get(self, "system_tags")

    @property
    @pulumi.getter(name="technologyType")
    def technology_type(self) -> str:
        """
        The Kafka (e.g. Confluent) Schema Registry technology type.
        """
        return pulumi.get(self, "technology_type")

    @property
    @pulumi.getter(name="tenancyId")
    def tenancy_id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the related Oracle Cloud Infrastructure tenancy.
        """
        return pulumi.get(self, "tenancy_id")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The time the resource was created. The format is defined by [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2016-08-25T21:10:29.600Z`.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The time the resource was last updated. The format is defined by [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2016-08-25T21:10:29.600Z`.
        """
        return pulumi.get(self, "time_updated")

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

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

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Kafka Schema Registry URL. e.g.: 'https://server1.us.oracle.com:8081'
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Oracle Cloud Infrastructure user who will access the Oracle NoSQL database/Object Storage. The user must have write access to the table they want to connect to.
        """
        return pulumi.get(self, "user_id")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username Oracle GoldenGate uses to connect the associated system of the given technology. This username must already exist and be available by the system/application to be connected to and must conform to the case sensitivity requirements defined in it.
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vaultId")
    def vault_id(self) -> str:
        """
        Refers to the customer's vault OCID.  If provided, it references a vault where GoldenGate can manage secrets. Customers must add policies to permit GoldenGate to manage secrets contained within this vault.
        """
        return pulumi.get(self, "vault_id")

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


class AwaitableGetConnectionResult(GetConnectionResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetConnectionResult(
            access_key_id=self.access_key_id,
            account_key=self.account_key,
            account_name=self.account_name,
            additional_attributes=self.additional_attributes,
            authentication_type=self.authentication_type,
            azure_tenant_id=self.azure_tenant_id,
            bootstrap_servers=self.bootstrap_servers,
            client_id=self.client_id,
            client_secret=self.client_secret,
            compartment_id=self.compartment_id,
            connection_factory=self.connection_factory,
            connection_id=self.connection_id,
            connection_string=self.connection_string,
            connection_type=self.connection_type,
            connection_url=self.connection_url,
            consumer_properties=self.consumer_properties,
            core_site_xml=self.core_site_xml,
            database_id=self.database_id,
            database_name=self.database_name,
            db_system_id=self.db_system_id,
            defined_tags=self.defined_tags,
            deployment_id=self.deployment_id,
            description=self.description,
            display_name=self.display_name,
            endpoint=self.endpoint,
            freeform_tags=self.freeform_tags,
            host=self.host,
            id=self.id,
            ingress_ips=self.ingress_ips,
            jndi_connection_factory=self.jndi_connection_factory,
            jndi_initial_context_factory=self.jndi_initial_context_factory,
            jndi_provider_url=self.jndi_provider_url,
            jndi_security_credentials=self.jndi_security_credentials,
            jndi_security_principal=self.jndi_security_principal,
            key_id=self.key_id,
            key_store=self.key_store,
            key_store_password=self.key_store_password,
            lifecycle_details=self.lifecycle_details,
            nsg_ids=self.nsg_ids,
            password=self.password,
            port=self.port,
            private_ip=self.private_ip,
            private_key_file=self.private_key_file,
            private_key_passphrase=self.private_key_passphrase,
            producer_properties=self.producer_properties,
            public_key_fingerprint=self.public_key_fingerprint,
            region=self.region,
            sas_token=self.sas_token,
            secret_access_key=self.secret_access_key,
            security_protocol=self.security_protocol,
            session_mode=self.session_mode,
            should_use_jndi=self.should_use_jndi,
            should_validate_server_certificate=self.should_validate_server_certificate,
            ssl_ca=self.ssl_ca,
            ssl_cert=self.ssl_cert,
            ssl_crl=self.ssl_crl,
            ssl_key=self.ssl_key,
            ssl_key_password=self.ssl_key_password,
            ssl_mode=self.ssl_mode,
            state=self.state,
            stream_pool_id=self.stream_pool_id,
            subnet_id=self.subnet_id,
            system_tags=self.system_tags,
            technology_type=self.technology_type,
            tenancy_id=self.tenancy_id,
            time_created=self.time_created,
            time_updated=self.time_updated,
            trust_store=self.trust_store,
            trust_store_password=self.trust_store_password,
            url=self.url,
            user_id=self.user_id,
            username=self.username,
            vault_id=self.vault_id,
            wallet=self.wallet)


def get_connection(connection_id: Optional[str] = None,
                   opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetConnectionResult:
    """
    This data source provides details about a specific Connection resource in Oracle Cloud Infrastructure Golden Gate service.

    Retrieves a Connection.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_oci as oci

    test_connection = oci.GoldenGate.get_connection(connection_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    ```


    :param str connection_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of a Connection.
    """
    __args__ = dict()
    __args__['connectionId'] = connection_id
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('oci:GoldenGate/getConnection:getConnection', __args__, opts=opts, typ=GetConnectionResult).value

    return AwaitableGetConnectionResult(
        access_key_id=__ret__.access_key_id,
        account_key=__ret__.account_key,
        account_name=__ret__.account_name,
        additional_attributes=__ret__.additional_attributes,
        authentication_type=__ret__.authentication_type,
        azure_tenant_id=__ret__.azure_tenant_id,
        bootstrap_servers=__ret__.bootstrap_servers,
        client_id=__ret__.client_id,
        client_secret=__ret__.client_secret,
        compartment_id=__ret__.compartment_id,
        connection_factory=__ret__.connection_factory,
        connection_id=__ret__.connection_id,
        connection_string=__ret__.connection_string,
        connection_type=__ret__.connection_type,
        connection_url=__ret__.connection_url,
        consumer_properties=__ret__.consumer_properties,
        core_site_xml=__ret__.core_site_xml,
        database_id=__ret__.database_id,
        database_name=__ret__.database_name,
        db_system_id=__ret__.db_system_id,
        defined_tags=__ret__.defined_tags,
        deployment_id=__ret__.deployment_id,
        description=__ret__.description,
        display_name=__ret__.display_name,
        endpoint=__ret__.endpoint,
        freeform_tags=__ret__.freeform_tags,
        host=__ret__.host,
        id=__ret__.id,
        ingress_ips=__ret__.ingress_ips,
        jndi_connection_factory=__ret__.jndi_connection_factory,
        jndi_initial_context_factory=__ret__.jndi_initial_context_factory,
        jndi_provider_url=__ret__.jndi_provider_url,
        jndi_security_credentials=__ret__.jndi_security_credentials,
        jndi_security_principal=__ret__.jndi_security_principal,
        key_id=__ret__.key_id,
        key_store=__ret__.key_store,
        key_store_password=__ret__.key_store_password,
        lifecycle_details=__ret__.lifecycle_details,
        nsg_ids=__ret__.nsg_ids,
        password=__ret__.password,
        port=__ret__.port,
        private_ip=__ret__.private_ip,
        private_key_file=__ret__.private_key_file,
        private_key_passphrase=__ret__.private_key_passphrase,
        producer_properties=__ret__.producer_properties,
        public_key_fingerprint=__ret__.public_key_fingerprint,
        region=__ret__.region,
        sas_token=__ret__.sas_token,
        secret_access_key=__ret__.secret_access_key,
        security_protocol=__ret__.security_protocol,
        session_mode=__ret__.session_mode,
        should_use_jndi=__ret__.should_use_jndi,
        should_validate_server_certificate=__ret__.should_validate_server_certificate,
        ssl_ca=__ret__.ssl_ca,
        ssl_cert=__ret__.ssl_cert,
        ssl_crl=__ret__.ssl_crl,
        ssl_key=__ret__.ssl_key,
        ssl_key_password=__ret__.ssl_key_password,
        ssl_mode=__ret__.ssl_mode,
        state=__ret__.state,
        stream_pool_id=__ret__.stream_pool_id,
        subnet_id=__ret__.subnet_id,
        system_tags=__ret__.system_tags,
        technology_type=__ret__.technology_type,
        tenancy_id=__ret__.tenancy_id,
        time_created=__ret__.time_created,
        time_updated=__ret__.time_updated,
        trust_store=__ret__.trust_store,
        trust_store_password=__ret__.trust_store_password,
        url=__ret__.url,
        user_id=__ret__.user_id,
        username=__ret__.username,
        vault_id=__ret__.vault_id,
        wallet=__ret__.wallet)


@_utilities.lift_output_func(get_connection)
def get_connection_output(connection_id: Optional[pulumi.Input[str]] = None,
                          opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetConnectionResult]:
    """
    This data source provides details about a specific Connection resource in Oracle Cloud Infrastructure Golden Gate service.

    Retrieves a Connection.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_oci as oci

    test_connection = oci.GoldenGate.get_connection(connection_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    ```


    :param str connection_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of a Connection.
    """
    ...
