pulumi-gcp 8.28.0a1745598508__py3-none-any.whl → 8.29.0__py3-none-any.whl

pulumi_gcp/compute/get_region_disk.py

@@ -28,7 +28,7 @@ class GetRegionDiskResult:
     """
     A collection of values returned by getRegionDisk.
     """
-    def __init__(__self__, async_primary_disks=None, create_snapshot_before_destroy=None, create_snapshot_before_destroy_prefix=None, creation_timestamp=None, description=None, disk_encryption_keys=None, effective_labels=None, guest_os_features=None, id=None, interface=None, label_fingerprint=None, labels=None, last_attach_timestamp=None, last_detach_timestamp=None, licenses=None, name=None, physical_block_size_bytes=None, project=None, pulumi_labels=None, region=None, replica_zones=None, self_link=None, size=None, snapshot=None, source_disk=None, source_disk_id=None, source_snapshot_encryption_keys=None, source_snapshot_id=None, type=None, users=None):
+    def __init__(__self__, async_primary_disks=None, create_snapshot_before_destroy=None, create_snapshot_before_destroy_prefix=None, creation_timestamp=None, description=None, disk_encryption_keys=None, disk_id=None, effective_labels=None, guest_os_features=None, id=None, interface=None, label_fingerprint=None, labels=None, last_attach_timestamp=None, last_detach_timestamp=None, licenses=None, name=None, physical_block_size_bytes=None, project=None, pulumi_labels=None, region=None, replica_zones=None, self_link=None, size=None, snapshot=None, source_disk=None, source_disk_id=None, source_snapshot_encryption_keys=None, source_snapshot_id=None, type=None, users=None):
         if async_primary_disks and not isinstance(async_primary_disks, list):
             raise TypeError("Expected argument 'async_primary_disks' to be a list")
         pulumi.set(__self__, "async_primary_disks", async_primary_disks)
@@ -47,6 +47,9 @@ class GetRegionDiskResult:
         if disk_encryption_keys and not isinstance(disk_encryption_keys, list):
             raise TypeError("Expected argument 'disk_encryption_keys' to be a list")
         pulumi.set(__self__, "disk_encryption_keys", disk_encryption_keys)
+        if disk_id and not isinstance(disk_id, str):
+            raise TypeError("Expected argument 'disk_id' to be a str")
+        pulumi.set(__self__, "disk_id", disk_id)
         if effective_labels and not isinstance(effective_labels, dict):
             raise TypeError("Expected argument 'effective_labels' to be a dict")
         pulumi.set(__self__, "effective_labels", effective_labels)
@@ -150,6 +153,11 @@ class GetRegionDiskResult:
     def disk_encryption_keys(self) -> Sequence['outputs.GetRegionDiskDiskEncryptionKeyResult']:
         return pulumi.get(self, "disk_encryption_keys")
 
+    @property
+    @pulumi.getter(name="diskId")
+    def disk_id(self) -> builtins.str:
+        return pulumi.get(self, "disk_id")
+
     @property
     @pulumi.getter(name="effectiveLabels")
     def effective_labels(self) -> Mapping[str, builtins.str]:
@@ -286,6 +294,7 @@ class AwaitableGetRegionDiskResult(GetRegionDiskResult):
             creation_timestamp=self.creation_timestamp,
             description=self.description,
             disk_encryption_keys=self.disk_encryption_keys,
+            disk_id=self.disk_id,
             effective_labels=self.effective_labels,
             guest_os_features=self.guest_os_features,
             id=self.id,
@@ -343,6 +352,7 @@ def get_region_disk(name: Optional[builtins.str] = None,
         creation_timestamp=pulumi.get(__ret__, 'creation_timestamp'),
         description=pulumi.get(__ret__, 'description'),
         disk_encryption_keys=pulumi.get(__ret__, 'disk_encryption_keys'),
+        disk_id=pulumi.get(__ret__, 'disk_id'),
         effective_labels=pulumi.get(__ret__, 'effective_labels'),
         guest_os_features=pulumi.get(__ret__, 'guest_os_features'),
         id=pulumi.get(__ret__, 'id'),
@@ -397,6 +407,7 @@ def get_region_disk_output(name: Optional[pulumi.Input[builtins.str]] = None,
         creation_timestamp=pulumi.get(__response__, 'creation_timestamp'),
         description=pulumi.get(__response__, 'description'),
         disk_encryption_keys=pulumi.get(__response__, 'disk_encryption_keys'),
+        disk_id=pulumi.get(__response__, 'disk_id'),
         effective_labels=pulumi.get(__response__, 'effective_labels'),
         guest_os_features=pulumi.get(__response__, 'guest_os_features'),
         id=pulumi.get(__response__, 'id'),

pulumi_gcp/compute/get_regions.py

@@ -93,12 +93,15 @@ def get_regions(project: Optional[builtins.str] = None,
 
     available = gcp.compute.get_regions()
     cluster = []
-    for range in [{"value": i} for i in range(0, len(available.names))]:
-        cluster.append(gcp.compute.Subnetwork(f"cluster-{range['value']}",
-            name="my-network",
-            ip_cidr_range=f"10.36.{range['value']}.0/24",
-            network="my-network",
-            region=available.names[range["value"]]))
+    def create_cluster(range_body):
+        for range in [{"value": i} for i in range(0, range_body)]:
+            cluster.append(gcp.compute.Subnetwork(f"cluster-{range['value']}",
+                name="my-network",
+                ip_cidr_range=f"10.36.{range['value']}.0/24",
+                network="my-network",
+                region=available.names[range["value"]]))
+
+    (len(available.names)).apply(create_cluster)
     ```
 
 
@@ -130,12 +133,15 @@ def get_regions_output(project: Optional[pulumi.Input[Optional[builtins.str]]] =
 
     available = gcp.compute.get_regions()
     cluster = []
-    for range in [{"value": i} for i in range(0, len(available.names))]:
-        cluster.append(gcp.compute.Subnetwork(f"cluster-{range['value']}",
-            name="my-network",
-            ip_cidr_range=f"10.36.{range['value']}.0/24",
-            network="my-network",
-            region=available.names[range["value"]]))
+    def create_cluster(range_body):
+        for range in [{"value": i} for i in range(0, range_body)]:
+            cluster.append(gcp.compute.Subnetwork(f"cluster-{range['value']}",
+                name="my-network",
+                ip_cidr_range=f"10.36.{range['value']}.0/24",
+                network="my-network",
+                region=available.names[range["value"]]))
+
+    (len(available.names)).apply(create_cluster)
     ```
 
 

pulumi_gcp/compute/get_storage_pool_iam_policy.py

@@ -0,0 +1,183 @@
+# 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 builtins
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+
+__all__ = [
+    'GetStoragePoolIamPolicyResult',
+    'AwaitableGetStoragePoolIamPolicyResult',
+    'get_storage_pool_iam_policy',
+    'get_storage_pool_iam_policy_output',
+]
+
+@pulumi.output_type
+class GetStoragePoolIamPolicyResult:
+    """
+    A collection of values returned by getStoragePoolIamPolicy.
+    """
+    def __init__(__self__, etag=None, id=None, name=None, policy_data=None, project=None, zone=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 name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", 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)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if zone and not isinstance(zone, str):
+            raise TypeError("Expected argument 'zone' to be a str")
+        pulumi.set(__self__, "zone", zone)
+
+    @property
+    @pulumi.getter
+    def etag(self) -> builtins.str:
+        """
+        (Computed) The etag of the IAM policy.
+        """
+        return pulumi.get(self, "etag")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="policyData")
+    def policy_data(self) -> builtins.str:
+        """
+        (Required only by `compute.StoragePoolIamPolicy`) The policy data generated by
+        a `organizations_get_iam_policy` data source.
+        """
+        return pulumi.get(self, "policy_data")
+
+    @property
+    @pulumi.getter
+    def project(self) -> builtins.str:
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter
+    def zone(self) -> builtins.str:
+        return pulumi.get(self, "zone")
+
+
+class AwaitableGetStoragePoolIamPolicyResult(GetStoragePoolIamPolicyResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetStoragePoolIamPolicyResult(
+            etag=self.etag,
+            id=self.id,
+            name=self.name,
+            policy_data=self.policy_data,
+            project=self.project,
+            zone=self.zone)
+
+
+def get_storage_pool_iam_policy(name: Optional[builtins.str] = None,
+                                project: Optional[builtins.str] = None,
+                                zone: Optional[builtins.str] = None,
+                                opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStoragePoolIamPolicyResult:
+    """
+    Retrieves the current IAM policy data for storagepool
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    policy = gcp.compute.get_storage_pool_iam_policy(project=test_storage_pool_basic["project"],
+        zone=test_storage_pool_basic["zone"],
+        name=test_storage_pool_basic["name"])
+    ```
+
+
+    :param builtins.str name: Used to find the parent resource to bind the IAM policy to
+    :param builtins.str project: The ID of the project in which the resource belongs.
+           If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
+    :param builtins.str zone: A reference to the zone where the storage pool resides. Used to find the parent resource to bind the IAM policy to. If not specified,
+           the value will be parsed from the identifier of the parent resource. If no zone is provided in the parent identifier and no
+           zone is specified, it is taken from the provider configuration.
+    """
+    __args__ = dict()
+    __args__['name'] = name
+    __args__['project'] = project
+    __args__['zone'] = zone
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:compute/getStoragePoolIamPolicy:getStoragePoolIamPolicy', __args__, opts=opts, typ=GetStoragePoolIamPolicyResult).value
+
+    return AwaitableGetStoragePoolIamPolicyResult(
+        etag=pulumi.get(__ret__, 'etag'),
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'),
+        policy_data=pulumi.get(__ret__, 'policy_data'),
+        project=pulumi.get(__ret__, 'project'),
+        zone=pulumi.get(__ret__, 'zone'))
+def get_storage_pool_iam_policy_output(name: Optional[pulumi.Input[builtins.str]] = None,
+                                       project: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                       zone: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                       opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetStoragePoolIamPolicyResult]:
+    """
+    Retrieves the current IAM policy data for storagepool
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    policy = gcp.compute.get_storage_pool_iam_policy(project=test_storage_pool_basic["project"],
+        zone=test_storage_pool_basic["zone"],
+        name=test_storage_pool_basic["name"])
+    ```
+
+
+    :param builtins.str name: Used to find the parent resource to bind the IAM policy to
+    :param builtins.str project: The ID of the project in which the resource belongs.
+           If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
+    :param builtins.str zone: A reference to the zone where the storage pool resides. Used to find the parent resource to bind the IAM policy to. If not specified,
+           the value will be parsed from the identifier of the parent resource. If no zone is provided in the parent identifier and no
+           zone is specified, it is taken from the provider configuration.
+    """
+    __args__ = dict()
+    __args__['name'] = name
+    __args__['project'] = project
+    __args__['zone'] = zone
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('gcp:compute/getStoragePoolIamPolicy:getStoragePoolIamPolicy', __args__, opts=opts, typ=GetStoragePoolIamPolicyResult)
+    return __ret__.apply(lambda __response__: GetStoragePoolIamPolicyResult(
+        etag=pulumi.get(__response__, 'etag'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name'),
+        policy_data=pulumi.get(__response__, 'policy_data'),
+        project=pulumi.get(__response__, 'project'),
+        zone=pulumi.get(__response__, 'zone')))

pulumi_gcp/compute/get_storage_pool_types.py

@@ -0,0 +1,268 @@
+# 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 builtins
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+from . import outputs
+
+__all__ = [
+    'GetStoragePoolTypesResult',
+    'AwaitableGetStoragePoolTypesResult',
+    'get_storage_pool_types',
+    'get_storage_pool_types_output',
+]
+
+@pulumi.output_type
+class GetStoragePoolTypesResult:
+    """
+    A collection of values returned by getStoragePoolTypes.
+    """
+    def __init__(__self__, creation_timestamp=None, deprecateds=None, description=None, id=None, kind=None, max_pool_provisioned_capacity_gb=None, max_pool_provisioned_iops=None, max_pool_provisioned_throughput=None, min_pool_provisioned_capacity_gb=None, min_pool_provisioned_iops=None, min_pool_provisioned_throughput=None, name=None, project=None, self_link=None, self_link_with_id=None, storage_pool_type=None, supported_disk_types=None, zone=None):
+        if creation_timestamp and not isinstance(creation_timestamp, str):
+            raise TypeError("Expected argument 'creation_timestamp' to be a str")
+        pulumi.set(__self__, "creation_timestamp", creation_timestamp)
+        if deprecateds and not isinstance(deprecateds, list):
+            raise TypeError("Expected argument 'deprecateds' to be a list")
+        pulumi.set(__self__, "deprecateds", deprecateds)
+        if description and not isinstance(description, str):
+            raise TypeError("Expected argument 'description' to be a str")
+        pulumi.set(__self__, "description", description)
+        if id and not isinstance(id, int):
+            raise TypeError("Expected argument 'id' to be a int")
+        pulumi.set(__self__, "id", id)
+        if kind and not isinstance(kind, str):
+            raise TypeError("Expected argument 'kind' to be a str")
+        pulumi.set(__self__, "kind", kind)
+        if max_pool_provisioned_capacity_gb and not isinstance(max_pool_provisioned_capacity_gb, int):
+            raise TypeError("Expected argument 'max_pool_provisioned_capacity_gb' to be a int")
+        pulumi.set(__self__, "max_pool_provisioned_capacity_gb", max_pool_provisioned_capacity_gb)
+        if max_pool_provisioned_iops and not isinstance(max_pool_provisioned_iops, int):
+            raise TypeError("Expected argument 'max_pool_provisioned_iops' to be a int")
+        pulumi.set(__self__, "max_pool_provisioned_iops", max_pool_provisioned_iops)
+        if max_pool_provisioned_throughput and not isinstance(max_pool_provisioned_throughput, int):
+            raise TypeError("Expected argument 'max_pool_provisioned_throughput' to be a int")
+        pulumi.set(__self__, "max_pool_provisioned_throughput", max_pool_provisioned_throughput)
+        if min_pool_provisioned_capacity_gb and not isinstance(min_pool_provisioned_capacity_gb, int):
+            raise TypeError("Expected argument 'min_pool_provisioned_capacity_gb' to be a int")
+        pulumi.set(__self__, "min_pool_provisioned_capacity_gb", min_pool_provisioned_capacity_gb)
+        if min_pool_provisioned_iops and not isinstance(min_pool_provisioned_iops, int):
+            raise TypeError("Expected argument 'min_pool_provisioned_iops' to be a int")
+        pulumi.set(__self__, "min_pool_provisioned_iops", min_pool_provisioned_iops)
+        if min_pool_provisioned_throughput and not isinstance(min_pool_provisioned_throughput, int):
+            raise TypeError("Expected argument 'min_pool_provisioned_throughput' to be a int")
+        pulumi.set(__self__, "min_pool_provisioned_throughput", min_pool_provisioned_throughput)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if self_link and not isinstance(self_link, str):
+            raise TypeError("Expected argument 'self_link' to be a str")
+        pulumi.set(__self__, "self_link", self_link)
+        if self_link_with_id and not isinstance(self_link_with_id, str):
+            raise TypeError("Expected argument 'self_link_with_id' to be a str")
+        pulumi.set(__self__, "self_link_with_id", self_link_with_id)
+        if storage_pool_type and not isinstance(storage_pool_type, str):
+            raise TypeError("Expected argument 'storage_pool_type' to be a str")
+        pulumi.set(__self__, "storage_pool_type", storage_pool_type)
+        if supported_disk_types and not isinstance(supported_disk_types, list):
+            raise TypeError("Expected argument 'supported_disk_types' to be a list")
+        pulumi.set(__self__, "supported_disk_types", supported_disk_types)
+        if zone and not isinstance(zone, str):
+            raise TypeError("Expected argument 'zone' to be a str")
+        pulumi.set(__self__, "zone", zone)
+
+    @property
+    @pulumi.getter(name="creationTimestamp")
+    def creation_timestamp(self) -> builtins.str:
+        return pulumi.get(self, "creation_timestamp")
+
+    @property
+    @pulumi.getter
+    def deprecateds(self) -> Sequence['outputs.GetStoragePoolTypesDeprecatedResult']:
+        return pulumi.get(self, "deprecateds")
+
+    @property
+    @pulumi.getter
+    def description(self) -> builtins.str:
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.int:
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def kind(self) -> builtins.str:
+        return pulumi.get(self, "kind")
+
+    @property
+    @pulumi.getter(name="maxPoolProvisionedCapacityGb")
+    def max_pool_provisioned_capacity_gb(self) -> builtins.int:
+        return pulumi.get(self, "max_pool_provisioned_capacity_gb")
+
+    @property
+    @pulumi.getter(name="maxPoolProvisionedIops")
+    def max_pool_provisioned_iops(self) -> builtins.int:
+        return pulumi.get(self, "max_pool_provisioned_iops")
+
+    @property
+    @pulumi.getter(name="maxPoolProvisionedThroughput")
+    def max_pool_provisioned_throughput(self) -> builtins.int:
+        return pulumi.get(self, "max_pool_provisioned_throughput")
+
+    @property
+    @pulumi.getter(name="minPoolProvisionedCapacityGb")
+    def min_pool_provisioned_capacity_gb(self) -> builtins.int:
+        return pulumi.get(self, "min_pool_provisioned_capacity_gb")
+
+    @property
+    @pulumi.getter(name="minPoolProvisionedIops")
+    def min_pool_provisioned_iops(self) -> builtins.int:
+        return pulumi.get(self, "min_pool_provisioned_iops")
+
+    @property
+    @pulumi.getter(name="minPoolProvisionedThroughput")
+    def min_pool_provisioned_throughput(self) -> builtins.int:
+        return pulumi.get(self, "min_pool_provisioned_throughput")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def project(self) -> builtins.str:
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter(name="selfLink")
+    def self_link(self) -> builtins.str:
+        return pulumi.get(self, "self_link")
+
+    @property
+    @pulumi.getter(name="selfLinkWithId")
+    def self_link_with_id(self) -> builtins.str:
+        return pulumi.get(self, "self_link_with_id")
+
+    @property
+    @pulumi.getter(name="storagePoolType")
+    def storage_pool_type(self) -> builtins.str:
+        return pulumi.get(self, "storage_pool_type")
+
+    @property
+    @pulumi.getter(name="supportedDiskTypes")
+    def supported_disk_types(self) -> Sequence[builtins.str]:
+        return pulumi.get(self, "supported_disk_types")
+
+    @property
+    @pulumi.getter
+    def zone(self) -> builtins.str:
+        return pulumi.get(self, "zone")
+
+
+class AwaitableGetStoragePoolTypesResult(GetStoragePoolTypesResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetStoragePoolTypesResult(
+            creation_timestamp=self.creation_timestamp,
+            deprecateds=self.deprecateds,
+            description=self.description,
+            id=self.id,
+            kind=self.kind,
+            max_pool_provisioned_capacity_gb=self.max_pool_provisioned_capacity_gb,
+            max_pool_provisioned_iops=self.max_pool_provisioned_iops,
+            max_pool_provisioned_throughput=self.max_pool_provisioned_throughput,
+            min_pool_provisioned_capacity_gb=self.min_pool_provisioned_capacity_gb,
+            min_pool_provisioned_iops=self.min_pool_provisioned_iops,
+            min_pool_provisioned_throughput=self.min_pool_provisioned_throughput,
+            name=self.name,
+            project=self.project,
+            self_link=self.self_link,
+            self_link_with_id=self.self_link_with_id,
+            storage_pool_type=self.storage_pool_type,
+            supported_disk_types=self.supported_disk_types,
+            zone=self.zone)
+
+
+def get_storage_pool_types(project: Optional[builtins.str] = None,
+                           storage_pool_type: Optional[builtins.str] = None,
+                           zone: Optional[builtins.str] = None,
+                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStoragePoolTypesResult:
+    """
+    Use this data source to access information about an existing resource.
+    """
+    __args__ = dict()
+    __args__['project'] = project
+    __args__['storagePoolType'] = storage_pool_type
+    __args__['zone'] = zone
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:compute/getStoragePoolTypes:getStoragePoolTypes', __args__, opts=opts, typ=GetStoragePoolTypesResult).value
+
+    return AwaitableGetStoragePoolTypesResult(
+        creation_timestamp=pulumi.get(__ret__, 'creation_timestamp'),
+        deprecateds=pulumi.get(__ret__, 'deprecateds'),
+        description=pulumi.get(__ret__, 'description'),
+        id=pulumi.get(__ret__, 'id'),
+        kind=pulumi.get(__ret__, 'kind'),
+        max_pool_provisioned_capacity_gb=pulumi.get(__ret__, 'max_pool_provisioned_capacity_gb'),
+        max_pool_provisioned_iops=pulumi.get(__ret__, 'max_pool_provisioned_iops'),
+        max_pool_provisioned_throughput=pulumi.get(__ret__, 'max_pool_provisioned_throughput'),
+        min_pool_provisioned_capacity_gb=pulumi.get(__ret__, 'min_pool_provisioned_capacity_gb'),
+        min_pool_provisioned_iops=pulumi.get(__ret__, 'min_pool_provisioned_iops'),
+        min_pool_provisioned_throughput=pulumi.get(__ret__, 'min_pool_provisioned_throughput'),
+        name=pulumi.get(__ret__, 'name'),
+        project=pulumi.get(__ret__, 'project'),
+        self_link=pulumi.get(__ret__, 'self_link'),
+        self_link_with_id=pulumi.get(__ret__, 'self_link_with_id'),
+        storage_pool_type=pulumi.get(__ret__, 'storage_pool_type'),
+        supported_disk_types=pulumi.get(__ret__, 'supported_disk_types'),
+        zone=pulumi.get(__ret__, 'zone'))
+def get_storage_pool_types_output(project: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                  storage_pool_type: Optional[pulumi.Input[builtins.str]] = None,
+                                  zone: Optional[pulumi.Input[builtins.str]] = None,
+                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetStoragePoolTypesResult]:
+    """
+    Use this data source to access information about an existing resource.
+    """
+    __args__ = dict()
+    __args__['project'] = project
+    __args__['storagePoolType'] = storage_pool_type
+    __args__['zone'] = zone
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('gcp:compute/getStoragePoolTypes:getStoragePoolTypes', __args__, opts=opts, typ=GetStoragePoolTypesResult)
+    return __ret__.apply(lambda __response__: GetStoragePoolTypesResult(
+        creation_timestamp=pulumi.get(__response__, 'creation_timestamp'),
+        deprecateds=pulumi.get(__response__, 'deprecateds'),
+        description=pulumi.get(__response__, 'description'),
+        id=pulumi.get(__response__, 'id'),
+        kind=pulumi.get(__response__, 'kind'),
+        max_pool_provisioned_capacity_gb=pulumi.get(__response__, 'max_pool_provisioned_capacity_gb'),
+        max_pool_provisioned_iops=pulumi.get(__response__, 'max_pool_provisioned_iops'),
+        max_pool_provisioned_throughput=pulumi.get(__response__, 'max_pool_provisioned_throughput'),
+        min_pool_provisioned_capacity_gb=pulumi.get(__response__, 'min_pool_provisioned_capacity_gb'),
+        min_pool_provisioned_iops=pulumi.get(__response__, 'min_pool_provisioned_iops'),
+        min_pool_provisioned_throughput=pulumi.get(__response__, 'min_pool_provisioned_throughput'),
+        name=pulumi.get(__response__, 'name'),
+        project=pulumi.get(__response__, 'project'),
+        self_link=pulumi.get(__response__, 'self_link'),
+        self_link_with_id=pulumi.get(__response__, 'self_link_with_id'),
+        storage_pool_type=pulumi.get(__response__, 'storage_pool_type'),
+        supported_disk_types=pulumi.get(__response__, 'supported_disk_types'),
+        zone=pulumi.get(__response__, 'zone')))

pulumi_gcp/compute/global_address.py

@@ -550,6 +550,9 @@ class _GlobalAddressState:
 
 
 class GlobalAddress(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/globalAddress:GlobalAddress"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/global_forwarding_rule.py

@@ -1235,6 +1235,9 @@ class _GlobalForwardingRuleState:
 
 
 class GlobalForwardingRule(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/globalForwardingRule:GlobalForwardingRule"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/global_network_endpoint.py

@@ -212,6 +212,9 @@ class _GlobalNetworkEndpointState:
 
 
 class GlobalNetworkEndpoint(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/globalNetworkEndpoint:GlobalNetworkEndpoint"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/global_network_endpoint_group.py

@@ -261,6 +261,9 @@ class _GlobalNetworkEndpointGroupState:
 
 
 class GlobalNetworkEndpointGroup(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/globalNetworkEndpointGroup:GlobalNetworkEndpointGroup"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/ha_vpn_gateway.py

@@ -477,6 +477,9 @@ class _HaVpnGatewayState:
 
 
 class HaVpnGateway(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/haVpnGateway:HaVpnGateway"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/health_check.py

@@ -700,6 +700,9 @@ class _HealthCheckState:
 
 
 class HealthCheck(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/healthCheck:HealthCheck"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/http_health_check.py

@@ -466,6 +466,9 @@ class _HttpHealthCheckState:
 
 
 class HttpHealthCheck(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/httpHealthCheck:HttpHealthCheck"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/https_health_check.py

@@ -466,6 +466,9 @@ class _HttpsHealthCheckState:
 
 
 class HttpsHealthCheck(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/httpsHealthCheck:HttpsHealthCheck"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/image.py

@@ -898,6 +898,9 @@ class _ImageState:
 
 
 class Image(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/image:Image"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/image_iam_binding.py

@@ -265,6 +265,9 @@ class _ImageIamBindingState:
 
 
 class ImageIamBinding(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/imageIamBinding:ImageIamBinding"
+
     @overload
     def __init__(__self__,
                  resource_name: str,