pulumi-gcp 8.18.0a1738650987__py3-none-any.whl → 8.19.0__py3-none-any.whl

pulumi_gcp/networkservices/_inputs.py

@@ -73,6 +73,8 @@ __all__ = [
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgsDict',
+    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgs',
+    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgsDict',
     'EndpointPolicyEndpointMatcherArgs',
@@ -1097,6 +1099,12 @@ if not MYPY:
         In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
         Structure is documented below.
         """
+        route_methods: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgsDict']]
+        """
+        Allow overriding the set of methods that are allowed for this route.
+        When not set, Media CDN allows only "GET", "HEAD", and "OPTIONS".
+        Structure is documented below.
+        """
         url_redirect: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgsDict']]
         """
         The URL redirect configuration for requests that match this route.
@@ -1114,6 +1122,7 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleArgs:
                  header_action: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs']] = None,
                  origin: Optional[pulumi.Input[str]] = None,
                  route_action: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs']] = None,
+                 route_methods: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgs']] = None,
                  url_redirect: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs']] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs']]] match_rules: The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates
@@ -1130,6 +1139,9 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleArgs:
                Only one of origin or urlRedirect can be set.
         :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs'] route_action: In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
                Structure is documented below.
+        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgs'] route_methods: Allow overriding the set of methods that are allowed for this route.
+               When not set, Media CDN allows only "GET", "HEAD", and "OPTIONS".
+               Structure is documented below.
         :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs'] url_redirect: The URL redirect configuration for requests that match this route.
                Structure is documented below.
         """
@@ -1143,6 +1155,8 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleArgs:
             pulumi.set(__self__, "origin", origin)
         if route_action is not None:
             pulumi.set(__self__, "route_action", route_action)
+        if route_methods is not None:
+            pulumi.set(__self__, "route_methods", route_methods)
         if url_redirect is not None:
             pulumi.set(__self__, "url_redirect", url_redirect)
 
@@ -1226,6 +1240,20 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleArgs:
     def route_action(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs']]):
         pulumi.set(self, "route_action", value)
 
+    @property
+    @pulumi.getter(name="routeMethods")
+    def route_methods(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgs']]:
+        """
+        Allow overriding the set of methods that are allowed for this route.
+        When not set, Media CDN allows only "GET", "HEAD", and "OPTIONS".
+        Structure is documented below.
+        """
+        return pulumi.get(self, "route_methods")
+
+    @route_methods.setter
+    def route_methods(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgs']]):
+        pulumi.set(self, "route_methods", value)
+
     @property
     @pulumi.getter(name="urlRedirect")
     def url_redirect(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs']]:
@@ -1923,6 +1951,12 @@ if not MYPY:
         The policy to use for defining caching and signed request behaviour for requests that match this route.
         Structure is documented below.
         """
+        compression_mode: NotRequired[pulumi.Input[str]]
+        """
+        Setting the compression mode to automatic enables dynamic compression for every eligible response.
+        When dynamic compression is enabled, it is recommended to also set a cache policy to maximize efficiency.
+        Possible values are: `DISABLED`, `AUTOMATIC`.
+        """
         cors_policy: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgsDict']]
         """
         CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
@@ -1940,11 +1974,15 @@ elif False:
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs:
     def __init__(__self__, *,
                  cdn_policy: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs']] = None,
+                 compression_mode: Optional[pulumi.Input[str]] = None,
                  cors_policy: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']] = None,
                  url_rewrite: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']] = None):
         """
         :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs'] cdn_policy: The policy to use for defining caching and signed request behaviour for requests that match this route.
                Structure is documented below.
+        :param pulumi.Input[str] compression_mode: Setting the compression mode to automatic enables dynamic compression for every eligible response.
+               When dynamic compression is enabled, it is recommended to also set a cache policy to maximize efficiency.
+               Possible values are: `DISABLED`, `AUTOMATIC`.
         :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs'] cors_policy: CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
                Structure is documented below.
         :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs'] url_rewrite: The URL rewrite configuration for requests that match this route.
@@ -1952,6 +1990,8 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs:
         """
         if cdn_policy is not None:
             pulumi.set(__self__, "cdn_policy", cdn_policy)
+        if compression_mode is not None:
+            pulumi.set(__self__, "compression_mode", compression_mode)
         if cors_policy is not None:
             pulumi.set(__self__, "cors_policy", cors_policy)
         if url_rewrite is not None:
@@ -1970,6 +2010,20 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs:
     def cdn_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs']]):
         pulumi.set(self, "cdn_policy", value)
 
+    @property
+    @pulumi.getter(name="compressionMode")
+    def compression_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        Setting the compression mode to automatic enables dynamic compression for every eligible response.
+        When dynamic compression is enabled, it is recommended to also set a cache policy to maximize efficiency.
+        Possible values are: `DISABLED`, `AUTOMATIC`.
+        """
+        return pulumi.get(self, "compression_mode")
+
+    @compression_mode.setter
+    def compression_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "compression_mode", value)
+
     @property
     @pulumi.getter(name="corsPolicy")
     def cors_policy(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']]:
@@ -3081,6 +3135,41 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs:
         pulumi.set(self, "path_template_rewrite", value)
 
 
+if not MYPY:
+    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgsDict(TypedDict):
+        allowed_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The non-empty set of HTTP methods that are allowed for this route.
+        Any combination of "GET", "HEAD", "OPTIONS", "PUT", "POST", "DELETE", and "PATCH".
+        """
+elif False:
+    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgs:
+    def __init__(__self__, *,
+                 allowed_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_methods: The non-empty set of HTTP methods that are allowed for this route.
+               Any combination of "GET", "HEAD", "OPTIONS", "PUT", "POST", "DELETE", and "PATCH".
+        """
+        if allowed_methods is not None:
+            pulumi.set(__self__, "allowed_methods", allowed_methods)
+
+    @property
+    @pulumi.getter(name="allowedMethods")
+    def allowed_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The non-empty set of HTTP methods that are allowed for this route.
+        Any combination of "GET", "HEAD", "OPTIONS", "PUT", "POST", "DELETE", and "PATCH".
+        """
+        return pulumi.get(self, "allowed_methods")
+
+    @allowed_methods.setter
+    def allowed_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "allowed_methods", value)
+
+
 if not MYPY:
     class EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgsDict(TypedDict):
         host_redirect: NotRequired[pulumi.Input[str]]

pulumi_gcp/networkservices/outputs.py

@@ -45,6 +45,7 @@ __all__ = [
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptions',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicy',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewrite',
+    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethods',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirect',
     'EndpointPolicyEndpointMatcher',
     'EndpointPolicyEndpointMatcherMetadataLabelMatcher',
@@ -863,6 +864,8 @@ class EdgeCacheServiceRoutingPathMatcherRouteRule(dict):
             suggest = "header_action"
         elif key == "routeAction":
             suggest = "route_action"
+        elif key == "routeMethods":
+            suggest = "route_methods"
         elif key == "urlRedirect":
             suggest = "url_redirect"
 
@@ -884,6 +887,7 @@ class EdgeCacheServiceRoutingPathMatcherRouteRule(dict):
                  header_action: Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderAction'] = None,
                  origin: Optional[str] = None,
                  route_action: Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction'] = None,
+                 route_methods: Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethods'] = None,
                  url_redirect: Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirect'] = None):
         """
         :param Sequence['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs'] match_rules: The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates
@@ -900,6 +904,9 @@ class EdgeCacheServiceRoutingPathMatcherRouteRule(dict):
                Only one of origin or urlRedirect can be set.
         :param 'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs' route_action: In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
                Structure is documented below.
+        :param 'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethodsArgs' route_methods: Allow overriding the set of methods that are allowed for this route.
+               When not set, Media CDN allows only "GET", "HEAD", and "OPTIONS".
+               Structure is documented below.
         :param 'EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs' url_redirect: The URL redirect configuration for requests that match this route.
                Structure is documented below.
         """
@@ -913,6 +920,8 @@ class EdgeCacheServiceRoutingPathMatcherRouteRule(dict):
             pulumi.set(__self__, "origin", origin)
         if route_action is not None:
             pulumi.set(__self__, "route_action", route_action)
+        if route_methods is not None:
+            pulumi.set(__self__, "route_methods", route_methods)
         if url_redirect is not None:
             pulumi.set(__self__, "url_redirect", url_redirect)
 
@@ -972,6 +981,16 @@ class EdgeCacheServiceRoutingPathMatcherRouteRule(dict):
         """
         return pulumi.get(self, "route_action")
 
+    @property
+    @pulumi.getter(name="routeMethods")
+    def route_methods(self) -> Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethods']:
+        """
+        Allow overriding the set of methods that are allowed for this route.
+        When not set, Media CDN allows only "GET", "HEAD", and "OPTIONS".
+        Structure is documented below.
+        """
+        return pulumi.get(self, "route_methods")
+
     @property
     @pulumi.getter(name="urlRedirect")
     def url_redirect(self) -> Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirect']:
@@ -1561,6 +1580,8 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction(dict):
         suggest = None
         if key == "cdnPolicy":
             suggest = "cdn_policy"
+        elif key == "compressionMode":
+            suggest = "compression_mode"
         elif key == "corsPolicy":
             suggest = "cors_policy"
         elif key == "urlRewrite":
@@ -1579,11 +1600,15 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction(dict):
 
     def __init__(__self__, *,
                  cdn_policy: Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicy'] = None,
+                 compression_mode: Optional[str] = None,
                  cors_policy: Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicy'] = None,
                  url_rewrite: Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewrite'] = None):
         """
         :param 'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs' cdn_policy: The policy to use for defining caching and signed request behaviour for requests that match this route.
                Structure is documented below.
+        :param str compression_mode: Setting the compression mode to automatic enables dynamic compression for every eligible response.
+               When dynamic compression is enabled, it is recommended to also set a cache policy to maximize efficiency.
+               Possible values are: `DISABLED`, `AUTOMATIC`.
         :param 'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs' cors_policy: CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
                Structure is documented below.
         :param 'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs' url_rewrite: The URL rewrite configuration for requests that match this route.
@@ -1591,6 +1616,8 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction(dict):
         """
         if cdn_policy is not None:
             pulumi.set(__self__, "cdn_policy", cdn_policy)
+        if compression_mode is not None:
+            pulumi.set(__self__, "compression_mode", compression_mode)
         if cors_policy is not None:
             pulumi.set(__self__, "cors_policy", cors_policy)
         if url_rewrite is not None:
@@ -1605,6 +1632,16 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction(dict):
         """
         return pulumi.get(self, "cdn_policy")
 
+    @property
+    @pulumi.getter(name="compressionMode")
+    def compression_mode(self) -> Optional[str]:
+        """
+        Setting the compression mode to automatic enables dynamic compression for every eligible response.
+        When dynamic compression is enabled, it is recommended to also set a cache policy to maximize efficiency.
+        Possible values are: `DISABLED`, `AUTOMATIC`.
+        """
+        return pulumi.get(self, "compression_mode")
+
     @property
     @pulumi.getter(name="corsPolicy")
     def cors_policy(self) -> Optional['outputs.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicy']:
@@ -2448,6 +2485,44 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewrite(dict):
         return pulumi.get(self, "path_template_rewrite")
 
 
+@pulumi.output_type
+class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethods(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allowedMethods":
+            suggest = "allowed_methods"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethods. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethods.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteMethods.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 allowed_methods: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] allowed_methods: The non-empty set of HTTP methods that are allowed for this route.
+               Any combination of "GET", "HEAD", "OPTIONS", "PUT", "POST", "DELETE", and "PATCH".
+        """
+        if allowed_methods is not None:
+            pulumi.set(__self__, "allowed_methods", allowed_methods)
+
+    @property
+    @pulumi.getter(name="allowedMethods")
+    def allowed_methods(self) -> Optional[Sequence[str]]:
+        """
+        The non-empty set of HTTP methods that are allowed for this route.
+        Any combination of "GET", "HEAD", "OPTIONS", "PUT", "POST", "DELETE", and "PATCH".
+        """
+        return pulumi.get(self, "allowed_methods")
+
+
 @pulumi.output_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirect(dict):
     @staticmethod

pulumi_gcp/orgpolicy/policy.py

@@ -313,7 +313,7 @@ class Policy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         constraint = gcp.orgpolicy.CustomConstraint("constraint",
-            name="custom.disableGkeAutoUpgrade_69391",
+            name="custom.disableGkeAutoUpgrade_8270",
             parent="organizations/123456789",
             display_name="Disable GKE auto upgrade",
             description="Only allow GKE NodePool resource to be created or updated if AutoUpgrade is not enabled where this custom constraint is enforced.",
@@ -502,7 +502,7 @@ class Policy(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         constraint = gcp.orgpolicy.CustomConstraint("constraint",
-            name="custom.disableGkeAutoUpgrade_69391",
+            name="custom.disableGkeAutoUpgrade_8270",
             parent="organizations/123456789",
             display_name="Disable GKE auto upgrade",
             description="Only allow GKE NodePool resource to be created or updated if AutoUpgrade is not enabled where this custom constraint is enforced.",

pulumi_gcp/parametermanager/__init__.py

@@ -6,7 +6,12 @@ from .. import _utilities
 import typing
 # Export this package's modules as members:
 from .get_parameter import *
+from .get_parameter_version import *
+from .get_parameter_version_render import *
+from .get_parameters import *
 from .get_regional_parameter import *
+from .get_regional_parameter_version import *
+from .get_regional_parameter_version_render import *
 from .get_regional_parameters import *
 from .parameter import *
 from .parameter_version import *

pulumi_gcp/parametermanager/get_parameter_version.py

@@ -0,0 +1,216 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import 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__ = [
+    'GetParameterVersionResult',
+    'AwaitableGetParameterVersionResult',
+    'get_parameter_version',
+    'get_parameter_version_output',
+]
+
+@pulumi.output_type
+class GetParameterVersionResult:
+    """
+    A collection of values returned by getParameterVersion.
+    """
+    def __init__(__self__, create_time=None, disabled=None, id=None, name=None, parameter=None, parameter_data=None, parameter_version_id=None, project=None, update_time=None):
+        if create_time and not isinstance(create_time, str):
+            raise TypeError("Expected argument 'create_time' to be a str")
+        pulumi.set(__self__, "create_time", create_time)
+        if disabled and not isinstance(disabled, bool):
+            raise TypeError("Expected argument 'disabled' to be a bool")
+        pulumi.set(__self__, "disabled", disabled)
+        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 parameter and not isinstance(parameter, str):
+            raise TypeError("Expected argument 'parameter' to be a str")
+        pulumi.set(__self__, "parameter", parameter)
+        if parameter_data and not isinstance(parameter_data, str):
+            raise TypeError("Expected argument 'parameter_data' to be a str")
+        pulumi.set(__self__, "parameter_data", parameter_data)
+        if parameter_version_id and not isinstance(parameter_version_id, str):
+            raise TypeError("Expected argument 'parameter_version_id' to be a str")
+        pulumi.set(__self__, "parameter_version_id", parameter_version_id)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if update_time and not isinstance(update_time, str):
+            raise TypeError("Expected argument 'update_time' to be a str")
+        pulumi.set(__self__, "update_time", update_time)
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
+        """
+        The time at which the Parameter Version was created.
+        """
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter
+    def disabled(self) -> bool:
+        """
+        The current state of the Parameter Version.
+        """
+        return pulumi.get(self, "disabled")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The resource name of the ParameterVersion. Format:
+        `projects/{{project}}/locations/global/parameters/{{parameter_id}}/versions/{{parameter_version_id}}`
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def parameter(self) -> str:
+        return pulumi.get(self, "parameter")
+
+    @property
+    @pulumi.getter(name="parameterData")
+    def parameter_data(self) -> str:
+        """
+        The parameter data.
+        """
+        return pulumi.get(self, "parameter_data")
+
+    @property
+    @pulumi.getter(name="parameterVersionId")
+    def parameter_version_id(self) -> str:
+        return pulumi.get(self, "parameter_version_id")
+
+    @property
+    @pulumi.getter
+    def project(self) -> str:
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter(name="updateTime")
+    def update_time(self) -> str:
+        """
+        The time at which the Parameter Version was last updated.
+        """
+        return pulumi.get(self, "update_time")
+
+
+class AwaitableGetParameterVersionResult(GetParameterVersionResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetParameterVersionResult(
+            create_time=self.create_time,
+            disabled=self.disabled,
+            id=self.id,
+            name=self.name,
+            parameter=self.parameter,
+            parameter_data=self.parameter_data,
+            parameter_version_id=self.parameter_version_id,
+            project=self.project,
+            update_time=self.update_time)
+
+
+def get_parameter_version(parameter: Optional[str] = None,
+                          parameter_version_id: Optional[str] = None,
+                          project: Optional[str] = None,
+                          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetParameterVersionResult:
+    """
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    basic = gcp.parametermanager.get_parameter_version(parameter="test-parameter",
+        parameter_version_id="test-parameter-version")
+    ```
+
+
+    :param str parameter: The parameter for obtaining the Parameter Version.
+           This can be either the reference of the parameter as in `projects/{{project}}/locations/global/parameters/{{parameter_id}}` or only the name of the parameter as in `{{parameter_id}}`.
+    :param str parameter_version_id: The version of the parameter to get.
+    :param str project: The project for retrieving the Parameter Version. If it's not specified, 
+           the provider project will be used.
+    """
+    __args__ = dict()
+    __args__['parameter'] = parameter
+    __args__['parameterVersionId'] = parameter_version_id
+    __args__['project'] = project
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:parametermanager/getParameterVersion:getParameterVersion', __args__, opts=opts, typ=GetParameterVersionResult).value
+
+    return AwaitableGetParameterVersionResult(
+        create_time=pulumi.get(__ret__, 'create_time'),
+        disabled=pulumi.get(__ret__, 'disabled'),
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'),
+        parameter=pulumi.get(__ret__, 'parameter'),
+        parameter_data=pulumi.get(__ret__, 'parameter_data'),
+        parameter_version_id=pulumi.get(__ret__, 'parameter_version_id'),
+        project=pulumi.get(__ret__, 'project'),
+        update_time=pulumi.get(__ret__, 'update_time'))
+def get_parameter_version_output(parameter: Optional[pulumi.Input[str]] = None,
+                                 parameter_version_id: Optional[pulumi.Input[str]] = None,
+                                 project: Optional[pulumi.Input[Optional[str]]] = None,
+                                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetParameterVersionResult]:
+    """
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    basic = gcp.parametermanager.get_parameter_version(parameter="test-parameter",
+        parameter_version_id="test-parameter-version")
+    ```
+
+
+    :param str parameter: The parameter for obtaining the Parameter Version.
+           This can be either the reference of the parameter as in `projects/{{project}}/locations/global/parameters/{{parameter_id}}` or only the name of the parameter as in `{{parameter_id}}`.
+    :param str parameter_version_id: The version of the parameter to get.
+    :param str project: The project for retrieving the Parameter Version. If it's not specified, 
+           the provider project will be used.
+    """
+    __args__ = dict()
+    __args__['parameter'] = parameter
+    __args__['parameterVersionId'] = parameter_version_id
+    __args__['project'] = project
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('gcp:parametermanager/getParameterVersion:getParameterVersion', __args__, opts=opts, typ=GetParameterVersionResult)
+    return __ret__.apply(lambda __response__: GetParameterVersionResult(
+        create_time=pulumi.get(__response__, 'create_time'),
+        disabled=pulumi.get(__response__, 'disabled'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name'),
+        parameter=pulumi.get(__response__, 'parameter'),
+        parameter_data=pulumi.get(__response__, 'parameter_data'),
+        parameter_version_id=pulumi.get(__response__, 'parameter_version_id'),
+        project=pulumi.get(__response__, 'project'),
+        update_time=pulumi.get(__response__, 'update_time')))