pulumi-gcp 8.19.0a1739290509__py3-none-any.whl → 8.19.1a1739444689__py3-none-any.whl

pulumi_gcp/memorystore/outputs.py

@@ -18,6 +18,9 @@ from . import outputs
 __all__ = [
     'InstanceDesiredPscAutoConnection',
     'InstanceDiscoveryEndpoint',
+    'InstanceEndpoint',
+    'InstanceEndpointConnection',
+    'InstanceEndpointConnectionPscAutoConnection',
     'InstanceNodeConfig',
     'InstancePersistenceConfig',
     'InstancePersistenceConfigAofConfig',
@@ -131,6 +134,227 @@ class InstanceDiscoveryEndpoint(dict):
         return pulumi.get(self, "port")
 
 
+@pulumi.output_type
+class InstanceEndpoint(dict):
+    def __init__(__self__, *,
+                 connections: Optional[Sequence['outputs.InstanceEndpointConnection']] = None):
+        """
+        :param Sequence['InstanceEndpointConnectionArgs'] connections: A group of PSC connections. They are created in the same VPC network, one for each service attachment in the cluster.
+               Structure is documented below.
+        """
+        if connections is not None:
+            pulumi.set(__self__, "connections", connections)
+
+    @property
+    @pulumi.getter
+    def connections(self) -> Optional[Sequence['outputs.InstanceEndpointConnection']]:
+        """
+        A group of PSC connections. They are created in the same VPC network, one for each service attachment in the cluster.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "connections")
+
+
+@pulumi.output_type
+class InstanceEndpointConnection(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "pscAutoConnection":
+            suggest = "psc_auto_connection"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceEndpointConnection. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceEndpointConnection.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceEndpointConnection.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 psc_auto_connection: Optional['outputs.InstanceEndpointConnectionPscAutoConnection'] = None):
+        """
+        :param 'InstanceEndpointConnectionPscAutoConnectionArgs' psc_auto_connection: Detailed information of a PSC connection that is created through service connectivity automation.
+               Structure is documented below.
+        """
+        if psc_auto_connection is not None:
+            pulumi.set(__self__, "psc_auto_connection", psc_auto_connection)
+
+    @property
+    @pulumi.getter(name="pscAutoConnection")
+    def psc_auto_connection(self) -> Optional['outputs.InstanceEndpointConnectionPscAutoConnection']:
+        """
+        Detailed information of a PSC connection that is created through service connectivity automation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_auto_connection")
+
+
+@pulumi.output_type
+class InstanceEndpointConnectionPscAutoConnection(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionType":
+            suggest = "connection_type"
+        elif key == "forwardingRule":
+            suggest = "forwarding_rule"
+        elif key == "ipAddress":
+            suggest = "ip_address"
+        elif key == "projectId":
+            suggest = "project_id"
+        elif key == "pscConnectionId":
+            suggest = "psc_connection_id"
+        elif key == "serviceAttachment":
+            suggest = "service_attachment"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceEndpointConnectionPscAutoConnection. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceEndpointConnectionPscAutoConnection.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceEndpointConnectionPscAutoConnection.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 connection_type: Optional[str] = None,
+                 forwarding_rule: Optional[str] = None,
+                 ip_address: Optional[str] = None,
+                 network: Optional[str] = None,
+                 port: Optional[int] = None,
+                 project_id: Optional[str] = None,
+                 psc_connection_id: Optional[str] = None,
+                 service_attachment: Optional[str] = None):
+        """
+        :param str connection_type: (Output)
+               Output Only. Type of a PSC Connection.
+               Possible values:
+               CONNECTION_TYPE_DISCOVERY
+               CONNECTION_TYPE_PRIMARY
+               CONNECTION_TYPE_READER
+        :param str forwarding_rule: (Output)
+               Output only. The URI of the consumer side forwarding rule.
+               Format:
+               projects/{project}/regions/{region}/forwardingRules/{forwarding_rule}
+        :param str ip_address: (Output)
+               Output only. The IP allocated on the consumer network for the PSC forwarding rule.
+        :param str network: (Output)
+               Output only. The consumer network where the IP address resides, in the form of
+               projects/{project_id}/global/networks/{network_id}.
+        :param int port: (Output)
+               Output only. Ports of the exposed endpoint.
+        :param str project_id: (Output)
+               Output only. The consumer project_id where the forwarding rule is created from.
+        :param str psc_connection_id: (Output)
+               Output only. The PSC connection id of the forwarding rule connected to the
+               service attachment.
+        :param str service_attachment: (Output)
+               Output only. The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
+        """
+        if connection_type is not None:
+            pulumi.set(__self__, "connection_type", connection_type)
+        if forwarding_rule is not None:
+            pulumi.set(__self__, "forwarding_rule", forwarding_rule)
+        if ip_address is not None:
+            pulumi.set(__self__, "ip_address", ip_address)
+        if network is not None:
+            pulumi.set(__self__, "network", network)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if project_id is not None:
+            pulumi.set(__self__, "project_id", project_id)
+        if psc_connection_id is not None:
+            pulumi.set(__self__, "psc_connection_id", psc_connection_id)
+        if service_attachment is not None:
+            pulumi.set(__self__, "service_attachment", service_attachment)
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> Optional[str]:
+        """
+        (Output)
+        Output Only. Type of a PSC Connection.
+        Possible values:
+        CONNECTION_TYPE_DISCOVERY
+        CONNECTION_TYPE_PRIMARY
+        CONNECTION_TYPE_READER
+        """
+        return pulumi.get(self, "connection_type")
+
+    @property
+    @pulumi.getter(name="forwardingRule")
+    def forwarding_rule(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The URI of the consumer side forwarding rule.
+        Format:
+        projects/{project}/regions/{region}/forwardingRules/{forwarding_rule}
+        """
+        return pulumi.get(self, "forwarding_rule")
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The IP allocated on the consumer network for the PSC forwarding rule.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @property
+    @pulumi.getter
+    def network(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The consumer network where the IP address resides, in the form of
+        projects/{project_id}/global/networks/{network_id}.
+        """
+        return pulumi.get(self, "network")
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[int]:
+        """
+        (Output)
+        Output only. Ports of the exposed endpoint.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter(name="projectId")
+    def project_id(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The consumer project_id where the forwarding rule is created from.
+        """
+        return pulumi.get(self, "project_id")
+
+    @property
+    @pulumi.getter(name="pscConnectionId")
+    def psc_connection_id(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The PSC connection id of the forwarding rule connected to the
+        service attachment.
+        """
+        return pulumi.get(self, "psc_connection_id")
+
+    @property
+    @pulumi.getter(name="serviceAttachment")
+    def service_attachment(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
+        """
+        return pulumi.get(self, "service_attachment")
+
+
 @pulumi.output_type
 class InstanceNodeConfig(dict):
     @staticmethod

pulumi_gcp/monitoring/_inputs.py

@@ -1441,9 +1441,10 @@ if not MYPY:
         Labels to add to or overwrite in the PromQL query result. Label names
         must be valid.
         Label values can be templatized by using variables. The only available
-        variable names are the names of the labels in the PromQL result, including
-        "__name__" and "value". "labels" may be empty. This field is intended to be
-        used for organizing and identifying the AlertPolicy
+        variable names are the names of the labels in the PromQL result,
+        although label names beginning with \\_\\_ (two "\\_") are reserved for
+        internal use. "labels" may be empty. This field is intended to be used
+        for organizing and identifying the AlertPolicy.
         """
         rule_group: NotRequired[pulumi.Input[str]]
         """
@@ -1493,9 +1494,10 @@ class AlertPolicyConditionConditionPrometheusQueryLanguageArgs:
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Labels to add to or overwrite in the PromQL query result. Label names
                must be valid.
                Label values can be templatized by using variables. The only available
-               variable names are the names of the labels in the PromQL result, including
-               "__name__" and "value". "labels" may be empty. This field is intended to be
-               used for organizing and identifying the AlertPolicy
+               variable names are the names of the labels in the PromQL result,
+               although label names beginning with \\_\\_ (two "\\_") are reserved for
+               internal use. "labels" may be empty. This field is intended to be used
+               for organizing and identifying the AlertPolicy.
         :param pulumi.Input[str] rule_group: The rule group name of this alert in the corresponding Prometheus
                configuration file.
                Some external tools may require this field to be populated correctly
@@ -1599,9 +1601,10 @@ class AlertPolicyConditionConditionPrometheusQueryLanguageArgs:
         Labels to add to or overwrite in the PromQL query result. Label names
         must be valid.
         Label values can be templatized by using variables. The only available
-        variable names are the names of the labels in the PromQL result, including
-        "__name__" and "value". "labels" may be empty. This field is intended to be
-        used for organizing and identifying the AlertPolicy
+        variable names are the names of the labels in the PromQL result,
+        although label names beginning with \\_\\_ (two "\\_") are reserved for
+        internal use. "labels" may be empty. This field is intended to be used
+        for organizing and identifying the AlertPolicy.
         """
         return pulumi.get(self, "labels")
 

pulumi_gcp/monitoring/outputs.py

@@ -1055,9 +1055,10 @@ class AlertPolicyConditionConditionPrometheusQueryLanguage(dict):
         :param Mapping[str, str] labels: Labels to add to or overwrite in the PromQL query result. Label names
                must be valid.
                Label values can be templatized by using variables. The only available
-               variable names are the names of the labels in the PromQL result, including
-               "__name__" and "value". "labels" may be empty. This field is intended to be
-               used for organizing and identifying the AlertPolicy
+               variable names are the names of the labels in the PromQL result,
+               although label names beginning with \\_\\_ (two "\\_") are reserved for
+               internal use. "labels" may be empty. This field is intended to be used
+               for organizing and identifying the AlertPolicy.
         :param str rule_group: The rule group name of this alert in the corresponding Prometheus
                configuration file.
                Some external tools may require this field to be populated correctly
@@ -1141,9 +1142,10 @@ class AlertPolicyConditionConditionPrometheusQueryLanguage(dict):
         Labels to add to or overwrite in the PromQL query result. Label names
         must be valid.
         Label values can be templatized by using variables. The only available
-        variable names are the names of the labels in the PromQL result, including
-        "__name__" and "value". "labels" may be empty. This field is intended to be
-        used for organizing and identifying the AlertPolicy
+        variable names are the names of the labels in the PromQL result,
+        although label names beginning with \\_\\_ (two "\\_") are reserved for
+        internal use. "labels" may be empty. This field is intended to be used
+        for organizing and identifying the AlertPolicy.
         """
         return pulumi.get(self, "labels")
 

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/parametermanager/__init__.py

@@ -7,9 +7,11 @@ 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 *