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

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

__all__ = [
    'GetSensitiveDataModelsSensitiveColumnResult',
    'AwaitableGetSensitiveDataModelsSensitiveColumnResult',
    'get_sensitive_data_models_sensitive_column',
    'get_sensitive_data_models_sensitive_column_output',
]

@pulumi.output_type
class GetSensitiveDataModelsSensitiveColumnResult:
    """
    A collection of values returned by getSensitiveDataModelsSensitiveColumn.
    """
    def __init__(__self__, app_defined_child_column_keys=None, app_name=None, column_groups=None, column_name=None, data_type=None, db_defined_child_column_keys=None, estimated_data_value_count=None, id=None, key=None, lifecycle_details=None, object=None, object_type=None, parent_column_keys=None, relation_type=None, sample_data_values=None, schema_name=None, sensitive_column_key=None, sensitive_data_model_id=None, sensitive_type_id=None, source=None, state=None, status=None, time_created=None, time_updated=None):
        if app_defined_child_column_keys and not isinstance(app_defined_child_column_keys, list):
            raise TypeError("Expected argument 'app_defined_child_column_keys' to be a list")
        pulumi.set(__self__, "app_defined_child_column_keys", app_defined_child_column_keys)
        if app_name and not isinstance(app_name, str):
            raise TypeError("Expected argument 'app_name' to be a str")
        pulumi.set(__self__, "app_name", app_name)
        if column_groups and not isinstance(column_groups, list):
            raise TypeError("Expected argument 'column_groups' to be a list")
        pulumi.set(__self__, "column_groups", column_groups)
        if column_name and not isinstance(column_name, str):
            raise TypeError("Expected argument 'column_name' to be a str")
        pulumi.set(__self__, "column_name", column_name)
        if data_type and not isinstance(data_type, str):
            raise TypeError("Expected argument 'data_type' to be a str")
        pulumi.set(__self__, "data_type", data_type)
        if db_defined_child_column_keys and not isinstance(db_defined_child_column_keys, list):
            raise TypeError("Expected argument 'db_defined_child_column_keys' to be a list")
        pulumi.set(__self__, "db_defined_child_column_keys", db_defined_child_column_keys)
        if estimated_data_value_count and not isinstance(estimated_data_value_count, str):
            raise TypeError("Expected argument 'estimated_data_value_count' to be a str")
        pulumi.set(__self__, "estimated_data_value_count", estimated_data_value_count)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if key and not isinstance(key, str):
            raise TypeError("Expected argument 'key' to be a str")
        pulumi.set(__self__, "key", key)
        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 object and not isinstance(object, str):
            raise TypeError("Expected argument 'object' to be a str")
        pulumi.set(__self__, "object", object)
        if object_type and not isinstance(object_type, str):
            raise TypeError("Expected argument 'object_type' to be a str")
        pulumi.set(__self__, "object_type", object_type)
        if parent_column_keys and not isinstance(parent_column_keys, list):
            raise TypeError("Expected argument 'parent_column_keys' to be a list")
        pulumi.set(__self__, "parent_column_keys", parent_column_keys)
        if relation_type and not isinstance(relation_type, str):
            raise TypeError("Expected argument 'relation_type' to be a str")
        pulumi.set(__self__, "relation_type", relation_type)
        if sample_data_values and not isinstance(sample_data_values, list):
            raise TypeError("Expected argument 'sample_data_values' to be a list")
        pulumi.set(__self__, "sample_data_values", sample_data_values)
        if schema_name and not isinstance(schema_name, str):
            raise TypeError("Expected argument 'schema_name' to be a str")
        pulumi.set(__self__, "schema_name", schema_name)
        if sensitive_column_key and not isinstance(sensitive_column_key, str):
            raise TypeError("Expected argument 'sensitive_column_key' to be a str")
        pulumi.set(__self__, "sensitive_column_key", sensitive_column_key)
        if sensitive_data_model_id and not isinstance(sensitive_data_model_id, str):
            raise TypeError("Expected argument 'sensitive_data_model_id' to be a str")
        pulumi.set(__self__, "sensitive_data_model_id", sensitive_data_model_id)
        if sensitive_type_id and not isinstance(sensitive_type_id, str):
            raise TypeError("Expected argument 'sensitive_type_id' to be a str")
        pulumi.set(__self__, "sensitive_type_id", sensitive_type_id)
        if source and not isinstance(source, str):
            raise TypeError("Expected argument 'source' to be a str")
        pulumi.set(__self__, "source", source)
        if state and not isinstance(state, str):
            raise TypeError("Expected argument 'state' to be a str")
        pulumi.set(__self__, "state", state)
        if status and not isinstance(status, str):
            raise TypeError("Expected argument 'status' to be a str")
        pulumi.set(__self__, "status", status)
        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)

    @property
    @pulumi.getter(name="appDefinedChildColumnKeys")
    def app_defined_child_column_keys(self) -> Sequence[str]:
        """
        Unique keys identifying the columns that are application-level (non-dictionary) children of the sensitive column.
        """
        return pulumi.get(self, "app_defined_child_column_keys")

    @property
    @pulumi.getter(name="appName")
    def app_name(self) -> str:
        """
        The name of the application associated with the sensitive column. It's useful when the application name is different from the schema name. Otherwise, it can be ignored.
        """
        return pulumi.get(self, "app_name")

    @property
    @pulumi.getter(name="columnGroups")
    def column_groups(self) -> Sequence[str]:
        """
        The composite key groups to which the sensitive column belongs. If the column is part of a composite key, it's assigned a column group. It helps identify and manage referential relationships that involve composite keys.
        """
        return pulumi.get(self, "column_groups")

    @property
    @pulumi.getter(name="columnName")
    def column_name(self) -> str:
        """
        The name of the sensitive column.
        """
        return pulumi.get(self, "column_name")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> str:
        """
        The data type of the sensitive column.
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter(name="dbDefinedChildColumnKeys")
    def db_defined_child_column_keys(self) -> Sequence[str]:
        """
        Unique keys identifying the columns that are database-level (dictionary-defined) children of the sensitive column.
        """
        return pulumi.get(self, "db_defined_child_column_keys")

    @property
    @pulumi.getter(name="estimatedDataValueCount")
    def estimated_data_value_count(self) -> str:
        """
        The estimated number of data values the column has in the associated database.
        """
        return pulumi.get(self, "estimated_data_value_count")

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

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def object(self) -> str:
        """
        The database object that contains the sensitive column.
        """
        return pulumi.get(self, "object")

    @property
    @pulumi.getter(name="objectType")
    def object_type(self) -> str:
        """
        The type of the database object that contains the sensitive column.
        """
        return pulumi.get(self, "object_type")

    @property
    @pulumi.getter(name="parentColumnKeys")
    def parent_column_keys(self) -> Sequence[str]:
        """
        Unique keys identifying the columns that are parents of the sensitive column. At present, it tracks a single parent only.
        """
        return pulumi.get(self, "parent_column_keys")

    @property
    @pulumi.getter(name="relationType")
    def relation_type(self) -> str:
        """
        The type of referential relationship the sensitive column has with its parent. NONE indicates that the sensitive column does not have a parent. DB_DEFINED indicates that the relationship is defined in the database dictionary. APP_DEFINED indicates that the relationship is defined at the application level and not in the database dictionary.
        """
        return pulumi.get(self, "relation_type")

    @property
    @pulumi.getter(name="sampleDataValues")
    def sample_data_values(self) -> Sequence[str]:
        """
        Original data values collected for the sensitive column from the associated database. Sample data helps review the column and ensure that it actually contains sensitive data. Note that sample data is retrieved by a data discovery job only if the isSampleDataCollectionEnabled attribute is set to true. At present, only one data value is collected per sensitive column.
        """
        return pulumi.get(self, "sample_data_values")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        The database schema that contains the sensitive column.
        """
        return pulumi.get(self, "schema_name")

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

    @property
    @pulumi.getter(name="sensitiveDataModelId")
    def sensitive_data_model_id(self) -> str:
        """
        The OCID of the sensitive data model that contains the sensitive column.
        """
        return pulumi.get(self, "sensitive_data_model_id")

    @property
    @pulumi.getter(name="sensitiveTypeId")
    def sensitive_type_id(self) -> str:
        """
        The OCID of the sensitive type associated with the sensitive column.
        """
        return pulumi.get(self, "sensitive_type_id")

    @property
    @pulumi.getter
    def source(self) -> str:
        """
        The source of the sensitive column. DISCOVERY indicates that the column was added to the sensitive data model using a data discovery job. MANUAL indicates that the column was added manually.
        """
        return pulumi.get(self, "source")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The current state of the sensitive column.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the sensitive column. VALID means the column is considered sensitive. INVALID means the column is not considered sensitive. Tracking invalid columns in a sensitive data model helps ensure that an incremental data discovery job does not identify these columns as sensitive again.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time, in the format defined by [RFC3339](https://tools.ietf.org/html/rfc3339), the sensitive column was created in the sensitive data model.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time, in the format defined by [RFC3339](https://tools.ietf.org/html/rfc3339), the sensitive column was last updated in the sensitive data model.
        """
        return pulumi.get(self, "time_updated")


class AwaitableGetSensitiveDataModelsSensitiveColumnResult(GetSensitiveDataModelsSensitiveColumnResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetSensitiveDataModelsSensitiveColumnResult(
            app_defined_child_column_keys=self.app_defined_child_column_keys,
            app_name=self.app_name,
            column_groups=self.column_groups,
            column_name=self.column_name,
            data_type=self.data_type,
            db_defined_child_column_keys=self.db_defined_child_column_keys,
            estimated_data_value_count=self.estimated_data_value_count,
            id=self.id,
            key=self.key,
            lifecycle_details=self.lifecycle_details,
            object=self.object,
            object_type=self.object_type,
            parent_column_keys=self.parent_column_keys,
            relation_type=self.relation_type,
            sample_data_values=self.sample_data_values,
            schema_name=self.schema_name,
            sensitive_column_key=self.sensitive_column_key,
            sensitive_data_model_id=self.sensitive_data_model_id,
            sensitive_type_id=self.sensitive_type_id,
            source=self.source,
            state=self.state,
            status=self.status,
            time_created=self.time_created,
            time_updated=self.time_updated)


def get_sensitive_data_models_sensitive_column(sensitive_column_key: Optional[str] = None,
                                               sensitive_data_model_id: Optional[str] = None,
                                               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSensitiveDataModelsSensitiveColumnResult:
    """
    This data source provides details about a specific Sensitive Data Models Sensitive Column resource in Oracle Cloud Infrastructure Data Safe service.

    Gets the details of the specified sensitive column.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_oci as oci

    test_sensitive_data_models_sensitive_column = oci.DataSafe.get_sensitive_data_models_sensitive_column(sensitive_column_key=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        sensitive_data_model_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    ```


    :param str sensitive_column_key: The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    :param str sensitive_data_model_id: The OCID of the sensitive data model.
    """
    __args__ = dict()
    __args__['sensitiveColumnKey'] = sensitive_column_key
    __args__['sensitiveDataModelId'] = sensitive_data_model_id
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('oci:DataSafe/getSensitiveDataModelsSensitiveColumn:getSensitiveDataModelsSensitiveColumn', __args__, opts=opts, typ=GetSensitiveDataModelsSensitiveColumnResult).value

    return AwaitableGetSensitiveDataModelsSensitiveColumnResult(
        app_defined_child_column_keys=__ret__.app_defined_child_column_keys,
        app_name=__ret__.app_name,
        column_groups=__ret__.column_groups,
        column_name=__ret__.column_name,
        data_type=__ret__.data_type,
        db_defined_child_column_keys=__ret__.db_defined_child_column_keys,
        estimated_data_value_count=__ret__.estimated_data_value_count,
        id=__ret__.id,
        key=__ret__.key,
        lifecycle_details=__ret__.lifecycle_details,
        object=__ret__.object,
        object_type=__ret__.object_type,
        parent_column_keys=__ret__.parent_column_keys,
        relation_type=__ret__.relation_type,
        sample_data_values=__ret__.sample_data_values,
        schema_name=__ret__.schema_name,
        sensitive_column_key=__ret__.sensitive_column_key,
        sensitive_data_model_id=__ret__.sensitive_data_model_id,
        sensitive_type_id=__ret__.sensitive_type_id,
        source=__ret__.source,
        state=__ret__.state,
        status=__ret__.status,
        time_created=__ret__.time_created,
        time_updated=__ret__.time_updated)


@_utilities.lift_output_func(get_sensitive_data_models_sensitive_column)
def get_sensitive_data_models_sensitive_column_output(sensitive_column_key: Optional[pulumi.Input[str]] = None,
                                                      sensitive_data_model_id: Optional[pulumi.Input[str]] = None,
                                                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetSensitiveDataModelsSensitiveColumnResult]:
    """
    This data source provides details about a specific Sensitive Data Models Sensitive Column resource in Oracle Cloud Infrastructure Data Safe service.

    Gets the details of the specified sensitive column.

    ## Example Usage

    ```python
    import pulumi
    import pulumi_oci as oci

    test_sensitive_data_models_sensitive_column = oci.DataSafe.get_sensitive_data_models_sensitive_column(sensitive_column_key=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        sensitive_data_model_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    ```


    :param str sensitive_column_key: The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
    :param str sensitive_data_model_id: The OCID of the sensitive data model.
    """
    ...
