pulumi-gcp 8.42.0a1756968228__py3-none-any.whl → 9.0.0a1__py3-none-any.whl

pulumi_gcp/bigquery/table.py

@@ -105,7 +105,9 @@ class TableArgs:
                type definition in field schema. Structure is documented below.
         :param pulumi.Input['TableTableConstraintsArgs'] table_constraints: Defines the primary key and foreign keys. 
                Structure is documented below.
-        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values: TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
+        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By
+               default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values:
+               TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
         :param pulumi.Input['TableTableReplicationInfoArgs'] table_replication_info: Replication info of a table created
                using "AS REPLICA" DDL like:
                `CREATE MATERIALIZED VIEW mv1 AS REPLICA OF src_mv`.
@@ -478,7 +480,9 @@ class TableArgs:
     @pulumi.getter(name="tableMetadataView")
     def table_metadata_view(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        View sets the optional parameter "view": Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values: TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
+        View sets the optional parameter "view": Specifies the view that determines which table information is returned. By
+        default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values:
+        TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
         """
         return pulumi.get(self, "table_metadata_view")
 
@@ -654,7 +658,9 @@ class _TableState:
                Structure is documented below.
         :param pulumi.Input[_builtins.str] table_id: A unique ID for the resource.
                Changing this forces a new resource to be created.
-        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values: TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
+        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By
+               default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values:
+               TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
         :param pulumi.Input['TableTableReplicationInfoArgs'] table_replication_info: Replication info of a table created
                using "AS REPLICA" DDL like:
                `CREATE MATERIALIZED VIEW mv1 AS REPLICA OF src_mv`.
@@ -1202,7 +1208,9 @@ class _TableState:
     @pulumi.getter(name="tableMetadataView")
     def table_metadata_view(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        View sets the optional parameter "view": Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values: TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
+        View sets the optional parameter "view": Specifies the view that determines which table information is returned. By
+        default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values:
+        TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
         """
         return pulumi.get(self, "table_metadata_view")
 
@@ -1440,7 +1448,9 @@ class Table(pulumi.CustomResource):
                Structure is documented below.
         :param pulumi.Input[_builtins.str] table_id: A unique ID for the resource.
                Changing this forces a new resource to be created.
-        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values: TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
+        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By
+               default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values:
+               TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
         :param pulumi.Input[Union['TableTableReplicationInfoArgs', 'TableTableReplicationInfoArgsDict']] table_replication_info: Replication info of a table created
                using "AS REPLICA" DDL like:
                `CREATE MATERIALIZED VIEW mv1 AS REPLICA OF src_mv`.
@@ -1775,7 +1785,9 @@ class Table(pulumi.CustomResource):
                Structure is documented below.
         :param pulumi.Input[_builtins.str] table_id: A unique ID for the resource.
                Changing this forces a new resource to be created.
-        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values: TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
+        :param pulumi.Input[_builtins.str] table_metadata_view: View sets the optional parameter "view": Specifies the view that determines which table information is returned. By
+               default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values:
+               TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
         :param pulumi.Input[Union['TableTableReplicationInfoArgs', 'TableTableReplicationInfoArgsDict']] table_replication_info: Replication info of a table created
                using "AS REPLICA" DDL like:
                `CREATE MATERIALIZED VIEW mv1 AS REPLICA OF src_mv`.
@@ -2153,7 +2165,9 @@ class Table(pulumi.CustomResource):
     @pulumi.getter(name="tableMetadataView")
     def table_metadata_view(self) -> pulumi.Output[Optional[_builtins.str]]:
         """
-        View sets the optional parameter "view": Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values: TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
+        View sets the optional parameter "view": Specifies the view that determines which table information is returned. By
+        default, basic table information and storage statistics (STORAGE_STATS) are returned. Possible values:
+        TABLE_METADATA_VIEW_UNSPECIFIED, BASIC, STORAGE_STATS, FULL
         """
         return pulumi.get(self, "table_metadata_view")
 

pulumi_gcp/bigtable/app_profile.py

@@ -40,13 +40,18 @@ class AppProfileArgs:
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input['AppProfileSingleClusterRoutingArgs'] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input['AppProfileStandardIsolationArgs'] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -139,7 +144,8 @@ class AppProfileArgs:
     @pulumi.getter(name="multiClusterRoutingClusterIds")
     def multi_cluster_routing_cluster_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+        clusters are eligible.
         """
         return pulumi.get(self, "multi_cluster_routing_cluster_ids")
 
@@ -178,7 +184,11 @@ class AppProfileArgs:
     @pulumi.getter(name="rowAffinity")
     def row_affinity(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+        affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+        will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+        read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+        is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         """
         return pulumi.get(self, "row_affinity")
 
@@ -236,14 +246,19 @@ class _AppProfileState:
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] name: The unique name of the requested app profile. Values are of the form `projects/<project>/instances/<instance>/appProfiles/<appProfileId>`.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input['AppProfileSingleClusterRoutingArgs'] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input['AppProfileStandardIsolationArgs'] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -339,7 +354,8 @@ class _AppProfileState:
     @pulumi.getter(name="multiClusterRoutingClusterIds")
     def multi_cluster_routing_cluster_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+        clusters are eligible.
         """
         return pulumi.get(self, "multi_cluster_routing_cluster_ids")
 
@@ -390,7 +406,11 @@ class _AppProfileState:
     @pulumi.getter(name="rowAffinity")
     def row_affinity(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+        affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+        will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+        read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+        is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         """
         return pulumi.get(self, "row_affinity")
 
@@ -610,13 +630,18 @@ class AppProfile(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input[Union['AppProfileSingleClusterRoutingArgs', 'AppProfileSingleClusterRoutingArgsDict']] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input[Union['AppProfileStandardIsolationArgs', 'AppProfileStandardIsolationArgsDict']] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -836,7 +861,7 @@ class AppProfile(pulumi.CustomResource):
             __props__.__dict__["single_cluster_routing"] = single_cluster_routing
             __props__.__dict__["standard_isolation"] = standard_isolation
             __props__.__dict__["name"] = None
-        alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="gcp:bigquery/appProfile:AppProfile")])
+        alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="gcp:bigquery/appProfile:AppProfile"), pulumi.Alias(type_="gcp:bigquery/appProfile:AppProfile")])
         opts = pulumi.ResourceOptions.merge(opts, alias_opts)
         super(AppProfile, __self__).__init__(
             'gcp:bigtable/appProfile:AppProfile',
@@ -873,14 +898,19 @@ class AppProfile(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] description: Long form description of the use case for this app profile.
         :param pulumi.Input[_builtins.bool] ignore_warnings: If true, ignore safety checks when deleting/updating the app profile.
         :param pulumi.Input[_builtins.str] instance: The name of the instance to create the app profile within.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] multi_cluster_routing_cluster_ids: The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+               clusters are eligible.
         :param pulumi.Input[_builtins.bool] multi_cluster_routing_use_any: If true, read/write requests are routed to the nearest cluster in the instance, and will fail over to the nearest cluster that is available
                in the event of transient errors or delays. Clusters in a region are considered equidistant. Choosing this option sacrifices read-your-writes
                consistency to improve availability.
         :param pulumi.Input[_builtins.str] name: The unique name of the requested app profile. Values are of the form `projects/<project>/instances/<instance>/appProfiles/<appProfileId>`.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        :param pulumi.Input[_builtins.bool] row_affinity: Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+               affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+               will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+               read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+               is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         :param pulumi.Input[Union['AppProfileSingleClusterRoutingArgs', 'AppProfileSingleClusterRoutingArgsDict']] single_cluster_routing: Use a single-cluster routing policy.
                Structure is documented below.
         :param pulumi.Input[Union['AppProfileStandardIsolationArgs', 'AppProfileStandardIsolationArgsDict']] standard_isolation: The standard options used for isolating this app profile's traffic from other use cases.
@@ -949,7 +979,8 @@ class AppProfile(pulumi.CustomResource):
     @pulumi.getter(name="multiClusterRoutingClusterIds")
     def multi_cluster_routing_cluster_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
         """
-        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all clusters are eligible.
+        The set of clusters to route to. The order is ignored; clusters will be tried in order of distance. If left empty, all
+        clusters are eligible.
         """
         return pulumi.get(self, "multi_cluster_routing_cluster_ids")
 
@@ -984,7 +1015,11 @@ class AppProfile(pulumi.CustomResource):
     @pulumi.getter(name="rowAffinity")
     def row_affinity(self) -> pulumi.Output[Optional[_builtins.bool]]:
         """
-        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
+        Must be used with multi-cluster routing. If true, then this app profile will use row affinity sticky routing. With row
+        affinity, Bigtable will route single row key requests based on the row key, rather than randomly. Instead, each row key
+        will be assigned to a cluster by Cloud Bigtable, and will stick to that cluster. Choosing this option improves
+        read-your-writes consistency for most requests under most circumstances, without sacrificing availability. Consistency
+        is not guaranteed, as requests may still fail over between clusters in the event of errors or latency.
         """
         return pulumi.get(self, "row_affinity")
 

pulumi_gcp/bigtable/get_table_iam_policy.py

@@ -26,16 +26,16 @@ class GetTableIamPolicyResult:
     """
     A collection of values returned by getTableIamPolicy.
     """
-    def __init__(__self__, etag=None, id=None, instance=None, policy_data=None, project=None, table=None):
+    def __init__(__self__, etag=None, id=None, instance_name=None, policy_data=None, project=None, table=None):
         if etag and not isinstance(etag, str):
             raise TypeError("Expected argument 'etag' to be a str")
         pulumi.set(__self__, "etag", etag)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
-        if instance and not isinstance(instance, str):
-            raise TypeError("Expected argument 'instance' to be a str")
-        pulumi.set(__self__, "instance", instance)
+        if instance_name and not isinstance(instance_name, str):
+            raise TypeError("Expected argument 'instance_name' to be a str")
+        pulumi.set(__self__, "instance_name", instance_name)
         if policy_data and not isinstance(policy_data, str):
             raise TypeError("Expected argument 'policy_data' to be a str")
         pulumi.set(__self__, "policy_data", policy_data)
@@ -63,9 +63,9 @@ class GetTableIamPolicyResult:
         return pulumi.get(self, "id")
 
     @_builtins.property
-    @pulumi.getter
-    def instance(self) -> _builtins.str:
-        return pulumi.get(self, "instance")
+    @pulumi.getter(name="instanceName")
+    def instance_name(self) -> _builtins.str:
+        return pulumi.get(self, "instance_name")
 
     @_builtins.property
     @pulumi.getter(name="policyData")
@@ -94,13 +94,13 @@ class AwaitableGetTableIamPolicyResult(GetTableIamPolicyResult):
         return GetTableIamPolicyResult(
             etag=self.etag,
             id=self.id,
-            instance=self.instance,
+            instance_name=self.instance_name,
             policy_data=self.policy_data,
             project=self.project,
             table=self.table)
 
 
-def get_table_iam_policy(instance: Optional[_builtins.str] = None,
+def get_table_iam_policy(instance_name: Optional[_builtins.str] = None,
                          project: Optional[_builtins.str] = None,
                          table: Optional[_builtins.str] = None,
                          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTableIamPolicyResult:
@@ -113,16 +113,15 @@ def get_table_iam_policy(instance: Optional[_builtins.str] = None,
     import pulumi
     import pulumi_gcp as gcp
 
-    policy = gcp.bigtable.get_table_iam_policy(instance=instance["name"],
+    policy = gcp.bigtable.get_table_iam_policy(instance_name=instance["name"],
         table=table["name"])
     ```
 
 
-    :param _builtins.str instance: The name or relative resource id of the instance that owns the table.
     :param _builtins.str table: The name or relative resource id of the table to manage IAM policies for.
     """
     __args__ = dict()
-    __args__['instance'] = instance
+    __args__['instanceName'] = instance_name
     __args__['project'] = project
     __args__['table'] = table
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
@@ -131,11 +130,11 @@ def get_table_iam_policy(instance: Optional[_builtins.str] = None,
     return AwaitableGetTableIamPolicyResult(
         etag=pulumi.get(__ret__, 'etag'),
         id=pulumi.get(__ret__, 'id'),
-        instance=pulumi.get(__ret__, 'instance'),
+        instance_name=pulumi.get(__ret__, 'instance_name'),
         policy_data=pulumi.get(__ret__, 'policy_data'),
         project=pulumi.get(__ret__, 'project'),
         table=pulumi.get(__ret__, 'table'))
-def get_table_iam_policy_output(instance: Optional[pulumi.Input[_builtins.str]] = None,
+def get_table_iam_policy_output(instance_name: Optional[pulumi.Input[_builtins.str]] = None,
                                 project: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                                 table: Optional[pulumi.Input[_builtins.str]] = None,
                                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTableIamPolicyResult]:
@@ -148,16 +147,15 @@ def get_table_iam_policy_output(instance: Optional[pulumi.Input[_builtins.str]]
     import pulumi
     import pulumi_gcp as gcp
 
-    policy = gcp.bigtable.get_table_iam_policy(instance=instance["name"],
+    policy = gcp.bigtable.get_table_iam_policy(instance_name=instance["name"],
         table=table["name"])
     ```
 
 
-    :param _builtins.str instance: The name or relative resource id of the instance that owns the table.
     :param _builtins.str table: The name or relative resource id of the table to manage IAM policies for.
     """
     __args__ = dict()
-    __args__['instance'] = instance
+    __args__['instanceName'] = instance_name
     __args__['project'] = project
     __args__['table'] = table
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
@@ -165,7 +163,7 @@ def get_table_iam_policy_output(instance: Optional[pulumi.Input[_builtins.str]]
     return __ret__.apply(lambda __response__: GetTableIamPolicyResult(
         etag=pulumi.get(__response__, 'etag'),
         id=pulumi.get(__response__, 'id'),
-        instance=pulumi.get(__response__, 'instance'),
+        instance_name=pulumi.get(__response__, 'instance_name'),
         policy_data=pulumi.get(__response__, 'policy_data'),
         project=pulumi.get(__response__, 'project'),
         table=pulumi.get(__response__, 'table')))

pulumi_gcp/bigtable/table.py

@@ -42,12 +42,12 @@ class TableArgs:
         :param pulumi.Input[_builtins.str] name: The name of the table. Must be 1-50 characters and must only contain hyphens, underscores, periods, letters and numbers.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs. If it
                is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
-               					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
-               				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n
-               					
-               					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
-               					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
+        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument. Note
+               that in-place update is not supported, and any in-place modification to the schema will lead to failure. To update a
+               schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n The schema must be a
+               valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like
+               delimited_bytes.delimiter) the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single
+               byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] split_keys: A list of predefined keys to split the table on.
                !> **Warning:** Modifying the `split_keys` of an existing table will cause the provider
                to delete/recreate the entire `bigtable.Table` resource.
@@ -161,12 +161,12 @@ class TableArgs:
     @pulumi.getter(name="rowKeySchema")
     def row_key_schema(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
-        					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
-        				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n
-        					
-        					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
-        					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
+        Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument. Note
+        that in-place update is not supported, and any in-place modification to the schema will lead to failure. To update a
+        schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n The schema must be a
+        valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like
+        delimited_bytes.delimiter) the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single
+        byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
         """
         return pulumi.get(self, "row_key_schema")
 
@@ -213,12 +213,12 @@ class _TableState:
         :param pulumi.Input[_builtins.str] name: The name of the table. Must be 1-50 characters and must only contain hyphens, underscores, periods, letters and numbers.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs. If it
                is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
-               					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
-               				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n
-               					
-               					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
-               					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
+        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument. Note
+               that in-place update is not supported, and any in-place modification to the schema will lead to failure. To update a
+               schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n The schema must be a
+               valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like
+               delimited_bytes.delimiter) the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single
+               byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] split_keys: A list of predefined keys to split the table on.
                !> **Warning:** Modifying the `split_keys` of an existing table will cause the provider
                to delete/recreate the entire `bigtable.Table` resource.
@@ -333,12 +333,12 @@ class _TableState:
     @pulumi.getter(name="rowKeySchema")
     def row_key_schema(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
-        					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
-        				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n
-        					
-        					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
-        					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
+        Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument. Note
+        that in-place update is not supported, and any in-place modification to the schema will lead to failure. To update a
+        schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n The schema must be a
+        valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like
+        delimited_bytes.delimiter) the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single
+        byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
         """
         return pulumi.get(self, "row_key_schema")
 
@@ -474,12 +474,12 @@ class Table(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] name: The name of the table. Must be 1-50 characters and must only contain hyphens, underscores, periods, letters and numbers.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs. If it
                is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
-               					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
-               				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n
-               					
-               					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
-               					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
+        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument. Note
+               that in-place update is not supported, and any in-place modification to the schema will lead to failure. To update a
+               schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n The schema must be a
+               valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like
+               delimited_bytes.delimiter) the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single
+               byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] split_keys: A list of predefined keys to split the table on.
                !> **Warning:** Modifying the `split_keys` of an existing table will cause the provider
                to delete/recreate the entire `bigtable.Table` resource.
@@ -655,12 +655,12 @@ class Table(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] name: The name of the table. Must be 1-50 characters and must only contain hyphens, underscores, periods, letters and numbers.
         :param pulumi.Input[_builtins.str] project: The ID of the project in which the resource belongs. If it
                is not provided, the provider project is used.
-        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
-               					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
-               				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n
-               					
-               					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
-               					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
+        :param pulumi.Input[_builtins.str] row_key_schema: Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument. Note
+               that in-place update is not supported, and any in-place modification to the schema will lead to failure. To update a
+               schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n The schema must be a
+               valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like
+               delimited_bytes.delimiter) the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single
+               byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] split_keys: A list of predefined keys to split the table on.
                !> **Warning:** Modifying the `split_keys` of an existing table will cause the provider
                to delete/recreate the entire `bigtable.Table` resource.
@@ -743,12 +743,12 @@ class Table(pulumi.CustomResource):
     @pulumi.getter(name="rowKeySchema")
     def row_key_schema(self) -> pulumi.Output[Optional[_builtins.str]]:
         """
-        Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument.
-        					Note that in-place update is not supported, and any in-place modification to the schema will lead to failure.
-        				    To update a schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n
-        					
-        					The schema must be a valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like delimited_bytes.delimiter)
-        					the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
+        Defines the row key schema of a table. To create or update a table with a row key schema, specify this argument. Note
+        that in-place update is not supported, and any in-place modification to the schema will lead to failure. To update a
+        schema, please clear it (by omitting the field), and update the resource again with a new schema.\\n The schema must be a
+        valid JSON encoded string representing a Type's struct protobuf message. Note that for bytes sequence (like
+        delimited_bytes.delimiter) the delimiter must be base64 encoded. For example, if you want to set a delimiter to a single
+        byte character "#", it should be set to "Iw==", which is the base64 encoding of the byte sequence "#".
         """
         return pulumi.get(self, "row_key_schema")