pulumi-gcp 8.13.0a1736231082__py3-none-any.whl → 8.13.1__py3-none-any.whl

pulumi_gcp/bigquery/outputs.py

@@ -39,6 +39,7 @@ __all__ = [
     'DatasetAccess',
     'DatasetAccessAuthorizedDataset',
     'DatasetAccessAuthorizedDatasetDataset',
+    'DatasetAccessCondition',
     'DatasetAccessDataset',
     'DatasetAccessDatasetDataset',
     'DatasetAccessRoutine',
@@ -77,6 +78,9 @@ __all__ = [
     'RoutineSparkOptions',
     'TableBiglakeConfiguration',
     'TableEncryptionConfiguration',
+    'TableExternalCatalogTableOptions',
+    'TableExternalCatalogTableOptionsStorageDescriptor',
+    'TableExternalCatalogTableOptionsStorageDescriptorSerdeInfo',
     'TableExternalDataConfiguration',
     'TableExternalDataConfigurationAvroOptions',
     'TableExternalDataConfigurationBigtableOptions',
@@ -99,6 +103,7 @@ __all__ = [
     'TableTimePartitioning',
     'TableView',
     'GetDatasetAccessResult',
+    'GetDatasetAccessConditionResult',
     'GetDatasetAccessDatasetResult',
     'GetDatasetAccessDatasetDatasetResult',
     'GetDatasetAccessRoutineResult',
@@ -1174,6 +1179,7 @@ class DatasetAccess(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 condition: Optional['outputs.DatasetAccessCondition'] = None,
                  dataset: Optional['outputs.DatasetAccessDataset'] = None,
                  domain: Optional[str] = None,
                  group_by_email: Optional[str] = None,
@@ -1184,6 +1190,9 @@ class DatasetAccess(dict):
                  user_by_email: Optional[str] = None,
                  view: Optional['outputs.DatasetAccessView'] = None):
         """
+        :param 'DatasetAccessConditionArgs' condition: Condition for the binding. If CEL expression in this field is true, this
+               access binding will be considered.
+               Structure is documented below.
         :param 'DatasetAccessDatasetArgs' dataset: Grants all resources of particular types in a particular dataset read access to the current dataset.
                Structure is documented below.
         :param str domain: A domain to grant access to. Any users signed in with the
@@ -1216,6 +1225,8 @@ class DatasetAccess(dict):
                needs to be granted again via an update operation.
                Structure is documented below.
         """
+        if condition is not None:
+            pulumi.set(__self__, "condition", condition)
         if dataset is not None:
             pulumi.set(__self__, "dataset", dataset)
         if domain is not None:
@@ -1235,6 +1246,16 @@ class DatasetAccess(dict):
         if view is not None:
             pulumi.set(__self__, "view", view)
 
+    @property
+    @pulumi.getter
+    def condition(self) -> Optional['outputs.DatasetAccessCondition']:
+        """
+        Condition for the binding. If CEL expression in this field is true, this
+        access binding will be considered.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "condition")
+
     @property
     @pulumi.getter
     def dataset(self) -> Optional['outputs.DatasetAccessDataset']:
@@ -1428,6 +1449,66 @@ class DatasetAccessAuthorizedDatasetDataset(dict):
         return pulumi.get(self, "project_id")
 
 
+@pulumi.output_type
+class DatasetAccessCondition(dict):
+    def __init__(__self__, *,
+                 expression: str,
+                 description: Optional[str] = None,
+                 location: Optional[str] = None,
+                 title: Optional[str] = None):
+        """
+        :param str expression: Textual representation of an expression in Common Expression Language syntax.
+        :param str description: Description of the expression. This is a longer text which describes the expression,
+               e.g. when hovered over it in a UI.
+        :param str location: String indicating the location of the expression for error reporting, e.g. a file
+               name and a position in the file.
+        :param str title: Title for the expression, i.e. a short string describing its purpose.
+               This can be used e.g. in UIs which allow to enter the expression.
+        """
+        pulumi.set(__self__, "expression", expression)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if location is not None:
+            pulumi.set(__self__, "location", location)
+        if title is not None:
+            pulumi.set(__self__, "title", title)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> str:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        Description of the expression. This is a longer text which describes the expression,
+        e.g. when hovered over it in a UI.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def location(self) -> Optional[str]:
+        """
+        String indicating the location of the expression for error reporting, e.g. a file
+        name and a position in the file.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def title(self) -> Optional[str]:
+        """
+        Title for the expression, i.e. a short string describing its purpose.
+        This can be used e.g. in UIs which allow to enter the expression.
+        """
+        return pulumi.get(self, "title")
+
+
 @pulumi.output_type
 class DatasetAccessDataset(dict):
     @staticmethod
@@ -4464,6 +4545,205 @@ class TableEncryptionConfiguration(dict):
         return pulumi.get(self, "kms_key_version")
 
 
+@pulumi.output_type
+class TableExternalCatalogTableOptions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionId":
+            suggest = "connection_id"
+        elif key == "storageDescriptor":
+            suggest = "storage_descriptor"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableExternalCatalogTableOptions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableExternalCatalogTableOptions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableExternalCatalogTableOptions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 connection_id: Optional[str] = None,
+                 parameters: Optional[Mapping[str, str]] = None,
+                 storage_descriptor: Optional['outputs.TableExternalCatalogTableOptionsStorageDescriptor'] = None):
+        """
+        :param str connection_id: The connection specifying the credentials to be used to read external storage, such as Azure Blob, Cloud Storage, or S3. The connection is needed to read the open source table from BigQuery Engine. The connection_id can have the form <project_id>.<location_id>.<connection_id> or projects/<project_id>/locations/<location_id>/connections/<connection_id>.
+        :param Mapping[str, str] parameters: A map of key value pairs defining the parameters and properties of the open source table. Corresponds with hive meta store table parameters. Maximum size of 4Mib.
+        :param 'TableExternalCatalogTableOptionsStorageDescriptorArgs' storage_descriptor: A storage descriptor containing information about the physical storage of this table.
+        """
+        if connection_id is not None:
+            pulumi.set(__self__, "connection_id", connection_id)
+        if parameters is not None:
+            pulumi.set(__self__, "parameters", parameters)
+        if storage_descriptor is not None:
+            pulumi.set(__self__, "storage_descriptor", storage_descriptor)
+
+    @property
+    @pulumi.getter(name="connectionId")
+    def connection_id(self) -> Optional[str]:
+        """
+        The connection specifying the credentials to be used to read external storage, such as Azure Blob, Cloud Storage, or S3. The connection is needed to read the open source table from BigQuery Engine. The connection_id can have the form <project_id>.<location_id>.<connection_id> or projects/<project_id>/locations/<location_id>/connections/<connection_id>.
+        """
+        return pulumi.get(self, "connection_id")
+
+    @property
+    @pulumi.getter
+    def parameters(self) -> Optional[Mapping[str, str]]:
+        """
+        A map of key value pairs defining the parameters and properties of the open source table. Corresponds with hive meta store table parameters. Maximum size of 4Mib.
+        """
+        return pulumi.get(self, "parameters")
+
+    @property
+    @pulumi.getter(name="storageDescriptor")
+    def storage_descriptor(self) -> Optional['outputs.TableExternalCatalogTableOptionsStorageDescriptor']:
+        """
+        A storage descriptor containing information about the physical storage of this table.
+        """
+        return pulumi.get(self, "storage_descriptor")
+
+
+@pulumi.output_type
+class TableExternalCatalogTableOptionsStorageDescriptor(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "inputFormat":
+            suggest = "input_format"
+        elif key == "locationUri":
+            suggest = "location_uri"
+        elif key == "outputFormat":
+            suggest = "output_format"
+        elif key == "serdeInfo":
+            suggest = "serde_info"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableExternalCatalogTableOptionsStorageDescriptor. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableExternalCatalogTableOptionsStorageDescriptor.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableExternalCatalogTableOptionsStorageDescriptor.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 input_format: Optional[str] = None,
+                 location_uri: Optional[str] = None,
+                 output_format: Optional[str] = None,
+                 serde_info: Optional['outputs.TableExternalCatalogTableOptionsStorageDescriptorSerdeInfo'] = None):
+        """
+        :param str input_format: Specifies the fully qualified class name of the InputFormat (e.g. "org.apache.hadoop.hive.ql.io.orc.OrcInputFormat"). The maximum length is 128 characters.
+        :param str location_uri: The physical location of the table (e.g. 'gs://spark-dataproc-data/pangea-data/case_sensitive/' or 'gs://spark-dataproc-data/pangea-data/*'). The maximum length is 2056 bytes.
+        :param str output_format: Specifies the fully qualified class name of the OutputFormat (e.g. "org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat"). The maximum length is 128 characters.
+        :param 'TableExternalCatalogTableOptionsStorageDescriptorSerdeInfoArgs' serde_info: Serializer and deserializer information.
+        """
+        if input_format is not None:
+            pulumi.set(__self__, "input_format", input_format)
+        if location_uri is not None:
+            pulumi.set(__self__, "location_uri", location_uri)
+        if output_format is not None:
+            pulumi.set(__self__, "output_format", output_format)
+        if serde_info is not None:
+            pulumi.set(__self__, "serde_info", serde_info)
+
+    @property
+    @pulumi.getter(name="inputFormat")
+    def input_format(self) -> Optional[str]:
+        """
+        Specifies the fully qualified class name of the InputFormat (e.g. "org.apache.hadoop.hive.ql.io.orc.OrcInputFormat"). The maximum length is 128 characters.
+        """
+        return pulumi.get(self, "input_format")
+
+    @property
+    @pulumi.getter(name="locationUri")
+    def location_uri(self) -> Optional[str]:
+        """
+        The physical location of the table (e.g. 'gs://spark-dataproc-data/pangea-data/case_sensitive/' or 'gs://spark-dataproc-data/pangea-data/*'). The maximum length is 2056 bytes.
+        """
+        return pulumi.get(self, "location_uri")
+
+    @property
+    @pulumi.getter(name="outputFormat")
+    def output_format(self) -> Optional[str]:
+        """
+        Specifies the fully qualified class name of the OutputFormat (e.g. "org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat"). The maximum length is 128 characters.
+        """
+        return pulumi.get(self, "output_format")
+
+    @property
+    @pulumi.getter(name="serdeInfo")
+    def serde_info(self) -> Optional['outputs.TableExternalCatalogTableOptionsStorageDescriptorSerdeInfo']:
+        """
+        Serializer and deserializer information.
+        """
+        return pulumi.get(self, "serde_info")
+
+
+@pulumi.output_type
+class TableExternalCatalogTableOptionsStorageDescriptorSerdeInfo(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "serializationLibrary":
+            suggest = "serialization_library"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableExternalCatalogTableOptionsStorageDescriptorSerdeInfo. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableExternalCatalogTableOptionsStorageDescriptorSerdeInfo.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableExternalCatalogTableOptionsStorageDescriptorSerdeInfo.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 serialization_library: str,
+                 name: Optional[str] = None,
+                 parameters: Optional[Mapping[str, str]] = None):
+        """
+        :param str serialization_library: Specifies a fully-qualified class name of the serialization library that is responsible for the translation of data between table representation and the underlying low-level input and output format structures. The maximum length is 256 characters.
+        :param str name: Name of the SerDe. The maximum length is 256 characters.
+        :param Mapping[str, str] parameters: Key-value pairs that define the initialization parameters for the serialization library. Maximum size 10 Kib.
+        """
+        pulumi.set(__self__, "serialization_library", serialization_library)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if parameters is not None:
+            pulumi.set(__self__, "parameters", parameters)
+
+    @property
+    @pulumi.getter(name="serializationLibrary")
+    def serialization_library(self) -> str:
+        """
+        Specifies a fully-qualified class name of the serialization library that is responsible for the translation of data between table representation and the underlying low-level input and output format structures. The maximum length is 256 characters.
+        """
+        return pulumi.get(self, "serialization_library")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        Name of the SerDe. The maximum length is 256 characters.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def parameters(self) -> Optional[Mapping[str, str]]:
+        """
+        Key-value pairs that define the initialization parameters for the serialization library. Maximum size 10 Kib.
+        """
+        return pulumi.get(self, "parameters")
+
+
 @pulumi.output_type
 class TableExternalDataConfiguration(dict):
     @staticmethod
@@ -6131,6 +6411,7 @@ class TableView(dict):
 @pulumi.output_type
 class GetDatasetAccessResult(dict):
     def __init__(__self__, *,
+                 conditions: Sequence['outputs.GetDatasetAccessConditionResult'],
                  datasets: Sequence['outputs.GetDatasetAccessDatasetResult'],
                  domain: str,
                  group_by_email: str,
@@ -6141,6 +6422,8 @@ class GetDatasetAccessResult(dict):
                  user_by_email: str,
                  views: Sequence['outputs.GetDatasetAccessViewResult']):
         """
+        :param Sequence['GetDatasetAccessConditionArgs'] conditions: Condition for the binding. If CEL expression in this field is true, this
+               access binding will be considered.
         :param Sequence['GetDatasetAccessDatasetArgs'] datasets: Grants all resources of particular types in a particular dataset read access to the current dataset.
         :param str domain: A domain to grant access to. Any users signed in with the
                domain specified will be granted the specified access
@@ -6170,6 +6453,7 @@ class GetDatasetAccessResult(dict):
                set. If that view is updated by any user, access to the view
                needs to be granted again via an update operation.
         """
+        pulumi.set(__self__, "conditions", conditions)
         pulumi.set(__self__, "datasets", datasets)
         pulumi.set(__self__, "domain", domain)
         pulumi.set(__self__, "group_by_email", group_by_email)
@@ -6180,6 +6464,15 @@ class GetDatasetAccessResult(dict):
         pulumi.set(__self__, "user_by_email", user_by_email)
         pulumi.set(__self__, "views", views)
 
+    @property
+    @pulumi.getter
+    def conditions(self) -> Sequence['outputs.GetDatasetAccessConditionResult']:
+        """
+        Condition for the binding. If CEL expression in this field is true, this
+        access binding will be considered.
+        """
+        return pulumi.get(self, "conditions")
+
     @property
     @pulumi.getter
     def datasets(self) -> Sequence['outputs.GetDatasetAccessDatasetResult']:
@@ -6272,6 +6565,63 @@ class GetDatasetAccessResult(dict):
         return pulumi.get(self, "views")
 
 
+@pulumi.output_type
+class GetDatasetAccessConditionResult(dict):
+    def __init__(__self__, *,
+                 description: str,
+                 expression: str,
+                 location: str,
+                 title: str):
+        """
+        :param str description: Description of the expression. This is a longer text which describes the expression,
+               e.g. when hovered over it in a UI.
+        :param str expression: Textual representation of an expression in Common Expression Language syntax.
+        :param str location: String indicating the location of the expression for error reporting, e.g. a file
+               name and a position in the file.
+        :param str title: Title for the expression, i.e. a short string describing its purpose.
+               This can be used e.g. in UIs which allow to enter the expression.
+        """
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "location", location)
+        pulumi.set(__self__, "title", title)
+
+    @property
+    @pulumi.getter
+    def description(self) -> str:
+        """
+        Description of the expression. This is a longer text which describes the expression,
+        e.g. when hovered over it in a UI.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def expression(self) -> str:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        String indicating the location of the expression for error reporting, e.g. a file
+        name and a position in the file.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def title(self) -> str:
+        """
+        Title for the expression, i.e. a short string describing its purpose.
+        This can be used e.g. in UIs which allow to enter the expression.
+        """
+        return pulumi.get(self, "title")
+
+
 @pulumi.output_type
 class GetDatasetAccessDatasetResult(dict):
     def __init__(__self__, *,

pulumi_gcp/bigquery/table.py

@@ -29,6 +29,7 @@ class TableArgs:
                  description: Optional[pulumi.Input[str]] = None,
                  encryption_configuration: Optional[pulumi.Input['TableEncryptionConfigurationArgs']] = None,
                  expiration_time: Optional[pulumi.Input[int]] = None,
+                 external_catalog_table_options: Optional[pulumi.Input['TableExternalCatalogTableOptionsArgs']] = None,
                  external_data_configuration: Optional[pulumi.Input['TableExternalDataConfigurationArgs']] = None,
                  friendly_name: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -63,6 +64,7 @@ class TableArgs:
                milliseconds since the epoch. If not present, the table will persist
                indefinitely. Expired tables will be deleted and their storage
                reclaimed.
+        :param pulumi.Input['TableExternalCatalogTableOptionsArgs'] external_catalog_table_options: Options defining open source compatible table.
         :param pulumi.Input['TableExternalDataConfigurationArgs'] external_data_configuration: Describes the data format,
                location, and other properties of a table stored outside of BigQuery.
                By defining these properties, the data source can then be queried as
@@ -116,6 +118,8 @@ class TableArgs:
             pulumi.set(__self__, "encryption_configuration", encryption_configuration)
         if expiration_time is not None:
             pulumi.set(__self__, "expiration_time", expiration_time)
+        if external_catalog_table_options is not None:
+            pulumi.set(__self__, "external_catalog_table_options", external_catalog_table_options)
         if external_data_configuration is not None:
             pulumi.set(__self__, "external_data_configuration", external_data_configuration)
         if friendly_name is not None:
@@ -251,6 +255,18 @@ class TableArgs:
     def expiration_time(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "expiration_time", value)
 
+    @property
+    @pulumi.getter(name="externalCatalogTableOptions")
+    def external_catalog_table_options(self) -> Optional[pulumi.Input['TableExternalCatalogTableOptionsArgs']]:
+        """
+        Options defining open source compatible table.
+        """
+        return pulumi.get(self, "external_catalog_table_options")
+
+    @external_catalog_table_options.setter
+    def external_catalog_table_options(self, value: Optional[pulumi.Input['TableExternalCatalogTableOptionsArgs']]):
+        pulumi.set(self, "external_catalog_table_options", value)
+
     @property
     @pulumi.getter(name="externalDataConfiguration")
     def external_data_configuration(self) -> Optional[pulumi.Input['TableExternalDataConfigurationArgs']]:
@@ -457,6 +473,7 @@ class _TableState:
                  encryption_configuration: Optional[pulumi.Input['TableEncryptionConfigurationArgs']] = None,
                  etag: Optional[pulumi.Input[str]] = None,
                  expiration_time: Optional[pulumi.Input[int]] = None,
+                 external_catalog_table_options: Optional[pulumi.Input['TableExternalCatalogTableOptionsArgs']] = None,
                  external_data_configuration: Optional[pulumi.Input['TableExternalDataConfigurationArgs']] = None,
                  friendly_name: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -516,6 +533,7 @@ class _TableState:
                milliseconds since the epoch. If not present, the table will persist
                indefinitely. Expired tables will be deleted and their storage
                reclaimed.
+        :param pulumi.Input['TableExternalCatalogTableOptionsArgs'] external_catalog_table_options: Options defining open source compatible table.
         :param pulumi.Input['TableExternalDataConfigurationArgs'] external_data_configuration: Describes the data format,
                location, and other properties of a table stored outside of BigQuery.
                By defining these properties, the data source can then be queried as
@@ -585,6 +603,8 @@ class _TableState:
             pulumi.set(__self__, "etag", etag)
         if expiration_time is not None:
             pulumi.set(__self__, "expiration_time", expiration_time)
+        if external_catalog_table_options is not None:
+            pulumi.set(__self__, "external_catalog_table_options", external_catalog_table_options)
         if external_data_configuration is not None:
             pulumi.set(__self__, "external_data_configuration", external_data_configuration)
         if friendly_name is not None:
@@ -776,6 +796,18 @@ class _TableState:
     def expiration_time(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "expiration_time", value)
 
+    @property
+    @pulumi.getter(name="externalCatalogTableOptions")
+    def external_catalog_table_options(self) -> Optional[pulumi.Input['TableExternalCatalogTableOptionsArgs']]:
+        """
+        Options defining open source compatible table.
+        """
+        return pulumi.get(self, "external_catalog_table_options")
+
+    @external_catalog_table_options.setter
+    def external_catalog_table_options(self, value: Optional[pulumi.Input['TableExternalCatalogTableOptionsArgs']]):
+        pulumi.set(self, "external_catalog_table_options", value)
+
     @property
     @pulumi.getter(name="externalDataConfiguration")
     def external_data_configuration(self) -> Optional[pulumi.Input['TableExternalDataConfigurationArgs']]:
@@ -1090,6 +1122,7 @@ class Table(pulumi.CustomResource):
                  description: Optional[pulumi.Input[str]] = None,
                  encryption_configuration: Optional[pulumi.Input[Union['TableEncryptionConfigurationArgs', 'TableEncryptionConfigurationArgsDict']]] = None,
                  expiration_time: Optional[pulumi.Input[int]] = None,
+                 external_catalog_table_options: Optional[pulumi.Input[Union['TableExternalCatalogTableOptionsArgs', 'TableExternalCatalogTableOptionsArgsDict']]] = None,
                  external_data_configuration: Optional[pulumi.Input[Union['TableExternalDataConfigurationArgs', 'TableExternalDataConfigurationArgsDict']]] = None,
                  friendly_name: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -1209,6 +1242,7 @@ class Table(pulumi.CustomResource):
                milliseconds since the epoch. If not present, the table will persist
                indefinitely. Expired tables will be deleted and their storage
                reclaimed.
+        :param pulumi.Input[Union['TableExternalCatalogTableOptionsArgs', 'TableExternalCatalogTableOptionsArgsDict']] external_catalog_table_options: Options defining open source compatible table.
         :param pulumi.Input[Union['TableExternalDataConfigurationArgs', 'TableExternalDataConfigurationArgsDict']] external_data_configuration: Describes the data format,
                location, and other properties of a table stored outside of BigQuery.
                By defining these properties, the data source can then be queried as
@@ -1363,6 +1397,7 @@ class Table(pulumi.CustomResource):
                  description: Optional[pulumi.Input[str]] = None,
                  encryption_configuration: Optional[pulumi.Input[Union['TableEncryptionConfigurationArgs', 'TableEncryptionConfigurationArgsDict']]] = None,
                  expiration_time: Optional[pulumi.Input[int]] = None,
+                 external_catalog_table_options: Optional[pulumi.Input[Union['TableExternalCatalogTableOptionsArgs', 'TableExternalCatalogTableOptionsArgsDict']]] = None,
                  external_data_configuration: Optional[pulumi.Input[Union['TableExternalDataConfigurationArgs', 'TableExternalDataConfigurationArgsDict']]] = None,
                  friendly_name: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -1396,6 +1431,7 @@ class Table(pulumi.CustomResource):
             __props__.__dict__["description"] = description
             __props__.__dict__["encryption_configuration"] = encryption_configuration
             __props__.__dict__["expiration_time"] = expiration_time
+            __props__.__dict__["external_catalog_table_options"] = external_catalog_table_options
             __props__.__dict__["external_data_configuration"] = external_data_configuration
             __props__.__dict__["friendly_name"] = friendly_name
             __props__.__dict__["labels"] = labels
@@ -1446,6 +1482,7 @@ class Table(pulumi.CustomResource):
             encryption_configuration: Optional[pulumi.Input[Union['TableEncryptionConfigurationArgs', 'TableEncryptionConfigurationArgsDict']]] = None,
             etag: Optional[pulumi.Input[str]] = None,
             expiration_time: Optional[pulumi.Input[int]] = None,
+            external_catalog_table_options: Optional[pulumi.Input[Union['TableExternalCatalogTableOptionsArgs', 'TableExternalCatalogTableOptionsArgsDict']]] = None,
             external_data_configuration: Optional[pulumi.Input[Union['TableExternalDataConfigurationArgs', 'TableExternalDataConfigurationArgsDict']]] = None,
             friendly_name: Optional[pulumi.Input[str]] = None,
             labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -1510,6 +1547,7 @@ class Table(pulumi.CustomResource):
                milliseconds since the epoch. If not present, the table will persist
                indefinitely. Expired tables will be deleted and their storage
                reclaimed.
+        :param pulumi.Input[Union['TableExternalCatalogTableOptionsArgs', 'TableExternalCatalogTableOptionsArgsDict']] external_catalog_table_options: Options defining open source compatible table.
         :param pulumi.Input[Union['TableExternalDataConfigurationArgs', 'TableExternalDataConfigurationArgsDict']] external_data_configuration: Describes the data format,
                location, and other properties of a table stored outside of BigQuery.
                By defining these properties, the data source can then be queried as
@@ -1573,6 +1611,7 @@ class Table(pulumi.CustomResource):
         __props__.__dict__["encryption_configuration"] = encryption_configuration
         __props__.__dict__["etag"] = etag
         __props__.__dict__["expiration_time"] = expiration_time
+        __props__.__dict__["external_catalog_table_options"] = external_catalog_table_options
         __props__.__dict__["external_data_configuration"] = external_data_configuration
         __props__.__dict__["friendly_name"] = friendly_name
         __props__.__dict__["labels"] = labels
@@ -1702,6 +1741,14 @@ class Table(pulumi.CustomResource):
         """
         return pulumi.get(self, "expiration_time")
 
+    @property
+    @pulumi.getter(name="externalCatalogTableOptions")
+    def external_catalog_table_options(self) -> pulumi.Output[Optional['outputs.TableExternalCatalogTableOptions']]:
+        """
+        Options defining open source compatible table.
+        """
+        return pulumi.get(self, "external_catalog_table_options")
+
     @property
     @pulumi.getter(name="externalDataConfiguration")
     def external_data_configuration(self) -> pulumi.Output[Optional['outputs.TableExternalDataConfiguration']]:

pulumi_gcp/chronicle/__init__.py

@@ -0,0 +1,10 @@
+# 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! ***
+
+from .. import _utilities
+import typing
+# Export this package's modules as members:
+from .watchlist import *
+from ._inputs import *
+from . import outputs