# 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__ = [
    'DatasetDatasetFormatDetails',
    'DatasetDatasetFormatDetailsTextFileTypeMetadata',
    'DatasetDatasetSourceDetails',
    'DatasetInitialRecordGenerationConfiguration',
    'DatasetLabelSet',
    'DatasetLabelSetItem',
    'GetAnnotationFormatItemResult',
    'GetAnnotationFormatsAnnotationFormatCollectionResult',
    'GetAnnotationFormatsAnnotationFormatCollectionItemResult',
    'GetAnnotationFormatsFilterResult',
    'GetDatasetDatasetFormatDetailResult',
    'GetDatasetDatasetFormatDetailTextFileTypeMetadataResult',
    'GetDatasetDatasetSourceDetailResult',
    'GetDatasetInitialRecordGenerationConfigurationResult',
    'GetDatasetLabelSetResult',
    'GetDatasetLabelSetItemResult',
    'GetDatasetsDatasetCollectionResult',
    'GetDatasetsDatasetCollectionItemResult',
    'GetDatasetsDatasetCollectionItemDatasetFormatDetailResult',
    'GetDatasetsDatasetCollectionItemDatasetFormatDetailTextFileTypeMetadataResult',
    'GetDatasetsDatasetCollectionItemDatasetSourceDetailResult',
    'GetDatasetsDatasetCollectionItemInitialRecordGenerationConfigurationResult',
    'GetDatasetsDatasetCollectionItemLabelSetResult',
    'GetDatasetsDatasetCollectionItemLabelSetItemResult',
    'GetDatasetsFilterResult',
]

@pulumi.output_type
class DatasetDatasetFormatDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "formatType":
            suggest = "format_type"
        elif key == "textFileTypeMetadata":
            suggest = "text_file_type_metadata"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DatasetDatasetFormatDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DatasetDatasetFormatDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DatasetDatasetFormatDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 format_type: str,
                 text_file_type_metadata: Optional['outputs.DatasetDatasetFormatDetailsTextFileTypeMetadata'] = None):
        """
        :param str format_type: It defines the format type of text files.
        :param 'DatasetDatasetFormatDetailsTextFileTypeMetadataArgs' text_file_type_metadata: Metadata for files with text content.
        """
        pulumi.set(__self__, "format_type", format_type)
        if text_file_type_metadata is not None:
            pulumi.set(__self__, "text_file_type_metadata", text_file_type_metadata)

    @property
    @pulumi.getter(name="formatType")
    def format_type(self) -> str:
        """
        It defines the format type of text files.
        """
        return pulumi.get(self, "format_type")

    @property
    @pulumi.getter(name="textFileTypeMetadata")
    def text_file_type_metadata(self) -> Optional['outputs.DatasetDatasetFormatDetailsTextFileTypeMetadata']:
        """
        Metadata for files with text content.
        """
        return pulumi.get(self, "text_file_type_metadata")


@pulumi.output_type
class DatasetDatasetFormatDetailsTextFileTypeMetadata(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "columnIndex":
            suggest = "column_index"
        elif key == "formatType":
            suggest = "format_type"
        elif key == "columnDelimiter":
            suggest = "column_delimiter"
        elif key == "columnName":
            suggest = "column_name"
        elif key == "escapeCharacter":
            suggest = "escape_character"
        elif key == "lineDelimiter":
            suggest = "line_delimiter"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DatasetDatasetFormatDetailsTextFileTypeMetadata. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DatasetDatasetFormatDetailsTextFileTypeMetadata.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DatasetDatasetFormatDetailsTextFileTypeMetadata.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column_index: int,
                 format_type: str,
                 column_delimiter: Optional[str] = None,
                 column_name: Optional[str] = None,
                 escape_character: Optional[str] = None,
                 line_delimiter: Optional[str] = None):
        """
        :param int column_index: The index of a selected column. This is a zero-based index.
        :param str format_type: It defines the format type of text files.
        :param str column_delimiter: A column delimiter
        :param str column_name: The name of a selected column.
        :param str escape_character: An escape character.
        :param str line_delimiter: A line delimiter.
        """
        pulumi.set(__self__, "column_index", column_index)
        pulumi.set(__self__, "format_type", format_type)
        if column_delimiter is not None:
            pulumi.set(__self__, "column_delimiter", column_delimiter)
        if column_name is not None:
            pulumi.set(__self__, "column_name", column_name)
        if escape_character is not None:
            pulumi.set(__self__, "escape_character", escape_character)
        if line_delimiter is not None:
            pulumi.set(__self__, "line_delimiter", line_delimiter)

    @property
    @pulumi.getter(name="columnIndex")
    def column_index(self) -> int:
        """
        The index of a selected column. This is a zero-based index.
        """
        return pulumi.get(self, "column_index")

    @property
    @pulumi.getter(name="formatType")
    def format_type(self) -> str:
        """
        It defines the format type of text files.
        """
        return pulumi.get(self, "format_type")

    @property
    @pulumi.getter(name="columnDelimiter")
    def column_delimiter(self) -> Optional[str]:
        """
        A column delimiter
        """
        return pulumi.get(self, "column_delimiter")

    @property
    @pulumi.getter(name="columnName")
    def column_name(self) -> Optional[str]:
        """
        The name of a selected column.
        """
        return pulumi.get(self, "column_name")

    @property
    @pulumi.getter(name="escapeCharacter")
    def escape_character(self) -> Optional[str]:
        """
        An escape character.
        """
        return pulumi.get(self, "escape_character")

    @property
    @pulumi.getter(name="lineDelimiter")
    def line_delimiter(self) -> Optional[str]:
        """
        A line delimiter.
        """
        return pulumi.get(self, "line_delimiter")


@pulumi.output_type
class DatasetDatasetSourceDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceType":
            suggest = "source_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DatasetDatasetSourceDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DatasetDatasetSourceDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DatasetDatasetSourceDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket: str,
                 namespace: str,
                 source_type: str,
                 prefix: Optional[str] = None):
        """
        :param str bucket: The object storage bucket that contains the dataset data source.
        :param str namespace: The namespace of the bucket that contains the dataset data source.
        :param str source_type: The source type. OBJECT_STORAGE allows the user to describe where in object storage the dataset is.
        :param str prefix: A common path prefix shared by the objects that make up the dataset. Except for the CSV file type, records are not generated for the objects whose names exactly match with the prefix.
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "source_type", source_type)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def bucket(self) -> str:
        """
        The object storage bucket that contains the dataset data source.
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The namespace of the bucket that contains the dataset data source.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> str:
        """
        The source type. OBJECT_STORAGE allows the user to describe where in object storage the dataset is.
        """
        return pulumi.get(self, "source_type")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        A common path prefix shared by the objects that make up the dataset. Except for the CSV file type, records are not generated for the objects whose names exactly match with the prefix.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class DatasetInitialRecordGenerationConfiguration(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class DatasetLabelSet(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.DatasetLabelSetItem']):
        """
        :param Sequence['DatasetLabelSetItemArgs'] items: An ordered collection of labels that are unique by name.
        """
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.DatasetLabelSetItem']:
        """
        An ordered collection of labels that are unique by name.
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class DatasetLabelSetItem(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: An unique name for a label within its dataset.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        An unique name for a label within its dataset.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetAnnotationFormatItemResult(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: A unique name for the target AnnotationFormat for the Dataset.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A unique name for the target AnnotationFormat for the Dataset.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetAnnotationFormatsAnnotationFormatCollectionResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetAnnotationFormatsAnnotationFormatCollectionItemResult']):
        """
        :param Sequence['GetAnnotationFormatsAnnotationFormatCollectionItemArgs'] items: List of annotation formats.
        """
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetAnnotationFormatsAnnotationFormatCollectionItemResult']:
        """
        List of annotation formats.
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetAnnotationFormatsAnnotationFormatCollectionItemResult(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: A unique name for the target AnnotationFormat for the Dataset.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A unique name for the target AnnotationFormat for the Dataset.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetAnnotationFormatsFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: A unique name for the target AnnotationFormat for the Dataset.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A unique name for the target AnnotationFormat for the Dataset.
        """
        return pulumi.get(self, "name")

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

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


@pulumi.output_type
class GetDatasetDatasetFormatDetailResult(dict):
    def __init__(__self__, *,
                 format_type: str,
                 text_file_type_metadatas: Sequence['outputs.GetDatasetDatasetFormatDetailTextFileTypeMetadataResult']):
        """
        :param str format_type: It defines the format type of text files.
        :param Sequence['GetDatasetDatasetFormatDetailTextFileTypeMetadataArgs'] text_file_type_metadatas: Metadata for files with text content.
        """
        pulumi.set(__self__, "format_type", format_type)
        pulumi.set(__self__, "text_file_type_metadatas", text_file_type_metadatas)

    @property
    @pulumi.getter(name="formatType")
    def format_type(self) -> str:
        """
        It defines the format type of text files.
        """
        return pulumi.get(self, "format_type")

    @property
    @pulumi.getter(name="textFileTypeMetadatas")
    def text_file_type_metadatas(self) -> Sequence['outputs.GetDatasetDatasetFormatDetailTextFileTypeMetadataResult']:
        """
        Metadata for files with text content.
        """
        return pulumi.get(self, "text_file_type_metadatas")


@pulumi.output_type
class GetDatasetDatasetFormatDetailTextFileTypeMetadataResult(dict):
    def __init__(__self__, *,
                 column_delimiter: str,
                 column_index: int,
                 column_name: str,
                 escape_character: str,
                 format_type: str,
                 line_delimiter: str):
        """
        :param str column_delimiter: A column delimiter
        :param int column_index: The index of a selected column. This is a zero-based index.
        :param str column_name: The name of a selected column.
        :param str escape_character: An escape character.
        :param str format_type: It defines the format type of text files.
        :param str line_delimiter: A line delimiter.
        """
        pulumi.set(__self__, "column_delimiter", column_delimiter)
        pulumi.set(__self__, "column_index", column_index)
        pulumi.set(__self__, "column_name", column_name)
        pulumi.set(__self__, "escape_character", escape_character)
        pulumi.set(__self__, "format_type", format_type)
        pulumi.set(__self__, "line_delimiter", line_delimiter)

    @property
    @pulumi.getter(name="columnDelimiter")
    def column_delimiter(self) -> str:
        """
        A column delimiter
        """
        return pulumi.get(self, "column_delimiter")

    @property
    @pulumi.getter(name="columnIndex")
    def column_index(self) -> int:
        """
        The index of a selected column. This is a zero-based index.
        """
        return pulumi.get(self, "column_index")

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

    @property
    @pulumi.getter(name="escapeCharacter")
    def escape_character(self) -> str:
        """
        An escape character.
        """
        return pulumi.get(self, "escape_character")

    @property
    @pulumi.getter(name="formatType")
    def format_type(self) -> str:
        """
        It defines the format type of text files.
        """
        return pulumi.get(self, "format_type")

    @property
    @pulumi.getter(name="lineDelimiter")
    def line_delimiter(self) -> str:
        """
        A line delimiter.
        """
        return pulumi.get(self, "line_delimiter")


@pulumi.output_type
class GetDatasetDatasetSourceDetailResult(dict):
    def __init__(__self__, *,
                 bucket: str,
                 namespace: str,
                 prefix: str,
                 source_type: str):
        """
        :param str bucket: The object storage bucket that contains the dataset data source.
        :param str namespace: The namespace of the bucket that contains the dataset data source.
        :param str prefix: A common path prefix shared by the objects that make up the dataset. Except for the CSV file type, records are not generated for the objects whose names exactly match with the prefix.
        :param str source_type: The source type. OBJECT_STORAGE allows the user to describe where in object storage the dataset is.
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "source_type", source_type)

    @property
    @pulumi.getter
    def bucket(self) -> str:
        """
        The object storage bucket that contains the dataset data source.
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The namespace of the bucket that contains the dataset data source.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        A common path prefix shared by the objects that make up the dataset. Except for the CSV file type, records are not generated for the objects whose names exactly match with the prefix.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> str:
        """
        The source type. OBJECT_STORAGE allows the user to describe where in object storage the dataset is.
        """
        return pulumi.get(self, "source_type")


@pulumi.output_type
class GetDatasetInitialRecordGenerationConfigurationResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetDatasetLabelSetResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetDatasetLabelSetItemResult']):
        """
        :param Sequence['GetDatasetLabelSetItemArgs'] items: An ordered collection of labels that are unique by name.
        """
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetDatasetLabelSetItemResult']:
        """
        An ordered collection of labels that are unique by name.
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetDatasetLabelSetItemResult(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: An unique name for a label within its dataset.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        An unique name for a label within its dataset.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetDatasetsDatasetCollectionResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetDatasetsDatasetCollectionItemResult']):
        """
        :param Sequence['GetDatasetsDatasetCollectionItemArgs'] items: An ordered collection of labels that are unique by name.
        """
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetDatasetsDatasetCollectionItemResult']:
        """
        An ordered collection of labels that are unique by name.
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetDatasetsDatasetCollectionItemResult(dict):
    def __init__(__self__, *,
                 annotation_format: str,
                 compartment_id: str,
                 dataset_format_details: Sequence['outputs.GetDatasetsDatasetCollectionItemDatasetFormatDetailResult'],
                 dataset_source_details: Sequence['outputs.GetDatasetsDatasetCollectionItemDatasetSourceDetailResult'],
                 defined_tags: Mapping[str, Any],
                 description: str,
                 display_name: str,
                 freeform_tags: Mapping[str, Any],
                 id: str,
                 initial_record_generation_configurations: Sequence['outputs.GetDatasetsDatasetCollectionItemInitialRecordGenerationConfigurationResult'],
                 label_sets: Sequence['outputs.GetDatasetsDatasetCollectionItemLabelSetResult'],
                 labeling_instructions: str,
                 lifecycle_details: str,
                 state: str,
                 time_created: str,
                 time_updated: str):
        """
        :param str annotation_format: A filter to return only resources that match the entire annotation format given.
        :param str compartment_id: The ID of the compartment in which to list resources.
        :param Sequence['GetDatasetsDatasetCollectionItemDatasetFormatDetailArgs'] dataset_format_details: It specifies how to process the data. Supported formats include DOCUMENT, IMAGE, and TEXT.
        :param Sequence['GetDatasetsDatasetCollectionItemDatasetSourceDetailArgs'] dataset_source_details: This allows the customer to specify the source of the dataset.
        :param Mapping[str, Any] defined_tags: The defined tags for this resource. Each key is predefined and scoped to a namespace. For example: `{"foo-namespace": {"bar-key": "value"}}`
        :param str description: A user provided description of the dataset
        :param str display_name: A filter to return only resources that match the entire display name given.
        :param Mapping[str, Any] freeform_tags: A simple key-value pair that is applied without any predefined name, type, or scope. It exists for cross-compatibility only. For example: `{"bar-key": "value"}`
        :param str id: Unique Dataset OCID
        :param Sequence['GetDatasetsDatasetCollectionItemInitialRecordGenerationConfigurationArgs'] initial_record_generation_configurations: The initial generate records configuration. It generates records from the dataset's source.
        :param Sequence['GetDatasetsDatasetCollectionItemLabelSetArgs'] label_sets: An ordered collection of labels that are unique by name.
        :param str labeling_instructions: The labeling instructions for human labelers in rich text format
        :param str lifecycle_details: A message describing the current state in more detail. For example, it can be used to provide actionable information for a resource in FAILED or NEEDS_ATTENTION state.
        :param str state: A filter to return only resources whose lifecycleState matches this query param.
        :param str time_created: The date and time the resource was created, in the timestamp format defined by RFC3339.
        :param str time_updated: The date and time the resource was last updated, in the timestamp format defined by RFC3339.
        """
        pulumi.set(__self__, "annotation_format", annotation_format)
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "dataset_format_details", dataset_format_details)
        pulumi.set(__self__, "dataset_source_details", dataset_source_details)
        pulumi.set(__self__, "defined_tags", defined_tags)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "initial_record_generation_configurations", initial_record_generation_configurations)
        pulumi.set(__self__, "label_sets", label_sets)
        pulumi.set(__self__, "labeling_instructions", labeling_instructions)
        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_updated", time_updated)

    @property
    @pulumi.getter(name="annotationFormat")
    def annotation_format(self) -> str:
        """
        A filter to return only resources that match the entire annotation format given.
        """
        return pulumi.get(self, "annotation_format")

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list resources.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="datasetFormatDetails")
    def dataset_format_details(self) -> Sequence['outputs.GetDatasetsDatasetCollectionItemDatasetFormatDetailResult']:
        """
        It specifies how to process the data. Supported formats include DOCUMENT, IMAGE, and TEXT.
        """
        return pulumi.get(self, "dataset_format_details")

    @property
    @pulumi.getter(name="datasetSourceDetails")
    def dataset_source_details(self) -> Sequence['outputs.GetDatasetsDatasetCollectionItemDatasetSourceDetailResult']:
        """
        This allows the customer to specify the source of the dataset.
        """
        return pulumi.get(self, "dataset_source_details")

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

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        A user provided description of the dataset
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A filter to return only resources that match the entire display name given.
        """
        return pulumi.get(self, "display_name")

    @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. It exists for cross-compatibility only. For example: `{"bar-key": "value"}`
        """
        return pulumi.get(self, "freeform_tags")

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

    @property
    @pulumi.getter(name="initialRecordGenerationConfigurations")
    def initial_record_generation_configurations(self) -> Sequence['outputs.GetDatasetsDatasetCollectionItemInitialRecordGenerationConfigurationResult']:
        """
        The initial generate records configuration. It generates records from the dataset's source.
        """
        return pulumi.get(self, "initial_record_generation_configurations")

    @property
    @pulumi.getter(name="labelSets")
    def label_sets(self) -> Sequence['outputs.GetDatasetsDatasetCollectionItemLabelSetResult']:
        """
        An ordered collection of labels that are unique by name.
        """
        return pulumi.get(self, "label_sets")

    @property
    @pulumi.getter(name="labelingInstructions")
    def labeling_instructions(self) -> str:
        """
        The labeling instructions for human labelers in rich text format
        """
        return pulumi.get(self, "labeling_instructions")

    @property
    @pulumi.getter(name="lifecycleDetails")
    def lifecycle_details(self) -> str:
        """
        A message describing the current state in more detail. For example, it can be used to provide actionable information for a resource in FAILED or NEEDS_ATTENTION state.
        """
        return pulumi.get(self, "lifecycle_details")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        A filter to return only resources whose lifecycleState matches this query param.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the resource was created, in the timestamp format defined by RFC3339.
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeUpdated")
    def time_updated(self) -> str:
        """
        The date and time the resource was last updated, in the timestamp format defined by RFC3339.
        """
        return pulumi.get(self, "time_updated")


@pulumi.output_type
class GetDatasetsDatasetCollectionItemDatasetFormatDetailResult(dict):
    def __init__(__self__, *,
                 format_type: str,
                 text_file_type_metadatas: Sequence['outputs.GetDatasetsDatasetCollectionItemDatasetFormatDetailTextFileTypeMetadataResult']):
        """
        :param str format_type: It defines the format type of text files.
        :param Sequence['GetDatasetsDatasetCollectionItemDatasetFormatDetailTextFileTypeMetadataArgs'] text_file_type_metadatas: Metadata for files with text content.
        """
        pulumi.set(__self__, "format_type", format_type)
        pulumi.set(__self__, "text_file_type_metadatas", text_file_type_metadatas)

    @property
    @pulumi.getter(name="formatType")
    def format_type(self) -> str:
        """
        It defines the format type of text files.
        """
        return pulumi.get(self, "format_type")

    @property
    @pulumi.getter(name="textFileTypeMetadatas")
    def text_file_type_metadatas(self) -> Sequence['outputs.GetDatasetsDatasetCollectionItemDatasetFormatDetailTextFileTypeMetadataResult']:
        """
        Metadata for files with text content.
        """
        return pulumi.get(self, "text_file_type_metadatas")


@pulumi.output_type
class GetDatasetsDatasetCollectionItemDatasetFormatDetailTextFileTypeMetadataResult(dict):
    def __init__(__self__, *,
                 column_delimiter: str,
                 column_index: int,
                 column_name: str,
                 escape_character: str,
                 format_type: str,
                 line_delimiter: str):
        """
        :param str column_delimiter: A column delimiter
        :param int column_index: The index of a selected column. This is a zero-based index.
        :param str column_name: The name of a selected column.
        :param str escape_character: An escape character.
        :param str format_type: It defines the format type of text files.
        :param str line_delimiter: A line delimiter.
        """
        pulumi.set(__self__, "column_delimiter", column_delimiter)
        pulumi.set(__self__, "column_index", column_index)
        pulumi.set(__self__, "column_name", column_name)
        pulumi.set(__self__, "escape_character", escape_character)
        pulumi.set(__self__, "format_type", format_type)
        pulumi.set(__self__, "line_delimiter", line_delimiter)

    @property
    @pulumi.getter(name="columnDelimiter")
    def column_delimiter(self) -> str:
        """
        A column delimiter
        """
        return pulumi.get(self, "column_delimiter")

    @property
    @pulumi.getter(name="columnIndex")
    def column_index(self) -> int:
        """
        The index of a selected column. This is a zero-based index.
        """
        return pulumi.get(self, "column_index")

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

    @property
    @pulumi.getter(name="escapeCharacter")
    def escape_character(self) -> str:
        """
        An escape character.
        """
        return pulumi.get(self, "escape_character")

    @property
    @pulumi.getter(name="formatType")
    def format_type(self) -> str:
        """
        It defines the format type of text files.
        """
        return pulumi.get(self, "format_type")

    @property
    @pulumi.getter(name="lineDelimiter")
    def line_delimiter(self) -> str:
        """
        A line delimiter.
        """
        return pulumi.get(self, "line_delimiter")


@pulumi.output_type
class GetDatasetsDatasetCollectionItemDatasetSourceDetailResult(dict):
    def __init__(__self__, *,
                 bucket: str,
                 namespace: str,
                 prefix: str,
                 source_type: str):
        """
        :param str bucket: The object storage bucket that contains the dataset data source.
        :param str namespace: The namespace of the bucket that contains the dataset data source.
        :param str prefix: A common path prefix shared by the objects that make up the dataset. Except for the CSV file type, records are not generated for the objects whose names exactly match with the prefix.
        :param str source_type: The source type. OBJECT_STORAGE allows the user to describe where in object storage the dataset is.
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "source_type", source_type)

    @property
    @pulumi.getter
    def bucket(self) -> str:
        """
        The object storage bucket that contains the dataset data source.
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The namespace of the bucket that contains the dataset data source.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        A common path prefix shared by the objects that make up the dataset. Except for the CSV file type, records are not generated for the objects whose names exactly match with the prefix.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> str:
        """
        The source type. OBJECT_STORAGE allows the user to describe where in object storage the dataset is.
        """
        return pulumi.get(self, "source_type")


@pulumi.output_type
class GetDatasetsDatasetCollectionItemInitialRecordGenerationConfigurationResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetDatasetsDatasetCollectionItemLabelSetResult(dict):
    def __init__(__self__, *,
                 items: Sequence['outputs.GetDatasetsDatasetCollectionItemLabelSetItemResult']):
        """
        :param Sequence['GetDatasetsDatasetCollectionItemLabelSetItemArgs'] items: An ordered collection of labels that are unique by name.
        """
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetDatasetsDatasetCollectionItemLabelSetItemResult']:
        """
        An ordered collection of labels that are unique by name.
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetDatasetsDatasetCollectionItemLabelSetItemResult(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: An unique name for a label within its dataset.
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        An unique name for a label within its dataset.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetDatasetsFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: An unique name for a label within its dataset.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        An unique name for a label within its dataset.
        """
        return pulumi.get(self, "name")

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

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


