pulumi-gcp 8.15.0a1737527599__py3-none-any.whl → 8.15.0a1737577694__py3-none-any.whl

pulumi_gcp/accesscontextmanager/service_perimeter_egress_policy.py

@@ -88,11 +88,13 @@ class ServicePerimeterEgressPolicyArgs:
 @pulumi.input_type
 class _ServicePerimeterEgressPolicyState:
     def __init__(__self__, *,
+                 access_policy_id: Optional[pulumi.Input[str]] = None,
                  egress_from: Optional[pulumi.Input['ServicePerimeterEgressPolicyEgressFromArgs']] = None,
                  egress_to: Optional[pulumi.Input['ServicePerimeterEgressPolicyEgressToArgs']] = None,
                  perimeter: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering ServicePerimeterEgressPolicy resources.
+        :param pulumi.Input[str] access_policy_id: The name of the Access Policy this resource belongs to.
         :param pulumi.Input['ServicePerimeterEgressPolicyEgressFromArgs'] egress_from: Defines conditions on the source of a request causing this `EgressPolicy` to apply.
                Structure is documented below.
         :param pulumi.Input['ServicePerimeterEgressPolicyEgressToArgs'] egress_to: Defines the conditions on the `ApiOperation` and destination resources that
@@ -103,6 +105,8 @@ class _ServicePerimeterEgressPolicyState:
                
                - - -
         """
+        if access_policy_id is not None:
+            pulumi.set(__self__, "access_policy_id", access_policy_id)
         if egress_from is not None:
             pulumi.set(__self__, "egress_from", egress_from)
         if egress_to is not None:
@@ -110,6 +114,18 @@ class _ServicePerimeterEgressPolicyState:
         if perimeter is not None:
             pulumi.set(__self__, "perimeter", perimeter)
 
+    @property
+    @pulumi.getter(name="accessPolicyId")
+    def access_policy_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the Access Policy this resource belongs to.
+        """
+        return pulumi.get(self, "access_policy_id")
+
+    @access_policy_id.setter
+    def access_policy_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "access_policy_id", value)
+
     @property
     @pulumi.getter(name="egressFrom")
     def egress_from(self) -> Optional[pulumi.Input['ServicePerimeterEgressPolicyEgressFromArgs']]:
@@ -262,6 +278,7 @@ class ServicePerimeterEgressPolicy(pulumi.CustomResource):
             if perimeter is None and not opts.urn:
                 raise TypeError("Missing required property 'perimeter'")
             __props__.__dict__["perimeter"] = perimeter
+            __props__.__dict__["access_policy_id"] = None
         super(ServicePerimeterEgressPolicy, __self__).__init__(
             'gcp:accesscontextmanager/servicePerimeterEgressPolicy:ServicePerimeterEgressPolicy',
             resource_name,
@@ -272,6 +289,7 @@ class ServicePerimeterEgressPolicy(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            access_policy_id: Optional[pulumi.Input[str]] = None,
             egress_from: Optional[pulumi.Input[Union['ServicePerimeterEgressPolicyEgressFromArgs', 'ServicePerimeterEgressPolicyEgressFromArgsDict']]] = None,
             egress_to: Optional[pulumi.Input[Union['ServicePerimeterEgressPolicyEgressToArgs', 'ServicePerimeterEgressPolicyEgressToArgsDict']]] = None,
             perimeter: Optional[pulumi.Input[str]] = None) -> 'ServicePerimeterEgressPolicy':
@@ -282,6 +300,7 @@ class ServicePerimeterEgressPolicy(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] access_policy_id: The name of the Access Policy this resource belongs to.
         :param pulumi.Input[Union['ServicePerimeterEgressPolicyEgressFromArgs', 'ServicePerimeterEgressPolicyEgressFromArgsDict']] egress_from: Defines conditions on the source of a request causing this `EgressPolicy` to apply.
                Structure is documented below.
         :param pulumi.Input[Union['ServicePerimeterEgressPolicyEgressToArgs', 'ServicePerimeterEgressPolicyEgressToArgsDict']] egress_to: Defines the conditions on the `ApiOperation` and destination resources that
@@ -296,11 +315,20 @@ class ServicePerimeterEgressPolicy(pulumi.CustomResource):
 
         __props__ = _ServicePerimeterEgressPolicyState.__new__(_ServicePerimeterEgressPolicyState)
 
+        __props__.__dict__["access_policy_id"] = access_policy_id
         __props__.__dict__["egress_from"] = egress_from
         __props__.__dict__["egress_to"] = egress_to
         __props__.__dict__["perimeter"] = perimeter
         return ServicePerimeterEgressPolicy(resource_name, opts=opts, __props__=__props__)
 
+    @property
+    @pulumi.getter(name="accessPolicyId")
+    def access_policy_id(self) -> pulumi.Output[str]:
+        """
+        The name of the Access Policy this resource belongs to.
+        """
+        return pulumi.get(self, "access_policy_id")
+
     @property
     @pulumi.getter(name="egressFrom")
     def egress_from(self) -> pulumi.Output[Optional['outputs.ServicePerimeterEgressPolicyEgressFrom']]:

pulumi_gcp/accesscontextmanager/service_perimeter_ingress_policy.py

@@ -90,11 +90,13 @@ class ServicePerimeterIngressPolicyArgs:
 @pulumi.input_type
 class _ServicePerimeterIngressPolicyState:
     def __init__(__self__, *,
+                 access_policy_id: Optional[pulumi.Input[str]] = None,
                  ingress_from: Optional[pulumi.Input['ServicePerimeterIngressPolicyIngressFromArgs']] = None,
                  ingress_to: Optional[pulumi.Input['ServicePerimeterIngressPolicyIngressToArgs']] = None,
                  perimeter: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering ServicePerimeterIngressPolicy resources.
+        :param pulumi.Input[str] access_policy_id: The name of the Access Policy this resource belongs to.
         :param pulumi.Input['ServicePerimeterIngressPolicyIngressFromArgs'] ingress_from: Defines the conditions on the source of a request causing this `IngressPolicy`
                to apply.
                Structure is documented below.
@@ -106,6 +108,8 @@ class _ServicePerimeterIngressPolicyState:
                
                - - -
         """
+        if access_policy_id is not None:
+            pulumi.set(__self__, "access_policy_id", access_policy_id)
         if ingress_from is not None:
             pulumi.set(__self__, "ingress_from", ingress_from)
         if ingress_to is not None:
@@ -113,6 +117,18 @@ class _ServicePerimeterIngressPolicyState:
         if perimeter is not None:
             pulumi.set(__self__, "perimeter", perimeter)
 
+    @property
+    @pulumi.getter(name="accessPolicyId")
+    def access_policy_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the Access Policy this resource belongs to.
+        """
+        return pulumi.get(self, "access_policy_id")
+
+    @access_policy_id.setter
+    def access_policy_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "access_policy_id", value)
+
     @property
     @pulumi.getter(name="ingressFrom")
     def ingress_from(self) -> Optional[pulumi.Input['ServicePerimeterIngressPolicyIngressFromArgs']]:
@@ -269,6 +285,7 @@ class ServicePerimeterIngressPolicy(pulumi.CustomResource):
             if perimeter is None and not opts.urn:
                 raise TypeError("Missing required property 'perimeter'")
             __props__.__dict__["perimeter"] = perimeter
+            __props__.__dict__["access_policy_id"] = None
         super(ServicePerimeterIngressPolicy, __self__).__init__(
             'gcp:accesscontextmanager/servicePerimeterIngressPolicy:ServicePerimeterIngressPolicy',
             resource_name,
@@ -279,6 +296,7 @@ class ServicePerimeterIngressPolicy(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            access_policy_id: Optional[pulumi.Input[str]] = None,
             ingress_from: Optional[pulumi.Input[Union['ServicePerimeterIngressPolicyIngressFromArgs', 'ServicePerimeterIngressPolicyIngressFromArgsDict']]] = None,
             ingress_to: Optional[pulumi.Input[Union['ServicePerimeterIngressPolicyIngressToArgs', 'ServicePerimeterIngressPolicyIngressToArgsDict']]] = None,
             perimeter: Optional[pulumi.Input[str]] = None) -> 'ServicePerimeterIngressPolicy':
@@ -289,6 +307,7 @@ class ServicePerimeterIngressPolicy(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] access_policy_id: The name of the Access Policy this resource belongs to.
         :param pulumi.Input[Union['ServicePerimeterIngressPolicyIngressFromArgs', 'ServicePerimeterIngressPolicyIngressFromArgsDict']] ingress_from: Defines the conditions on the source of a request causing this `IngressPolicy`
                to apply.
                Structure is documented below.
@@ -304,11 +323,20 @@ class ServicePerimeterIngressPolicy(pulumi.CustomResource):
 
         __props__ = _ServicePerimeterIngressPolicyState.__new__(_ServicePerimeterIngressPolicyState)
 
+        __props__.__dict__["access_policy_id"] = access_policy_id
         __props__.__dict__["ingress_from"] = ingress_from
         __props__.__dict__["ingress_to"] = ingress_to
         __props__.__dict__["perimeter"] = perimeter
         return ServicePerimeterIngressPolicy(resource_name, opts=opts, __props__=__props__)
 
+    @property
+    @pulumi.getter(name="accessPolicyId")
+    def access_policy_id(self) -> pulumi.Output[str]:
+        """
+        The name of the Access Policy this resource belongs to.
+        """
+        return pulumi.get(self, "access_policy_id")
+
     @property
     @pulumi.getter(name="ingressFrom")
     def ingress_from(self) -> pulumi.Output[Optional['outputs.ServicePerimeterIngressPolicyIngressFrom']]:

pulumi_gcp/accesscontextmanager/service_perimeter_resource.py

@@ -67,10 +67,14 @@ class ServicePerimeterResourceArgs:
 @pulumi.input_type
 class _ServicePerimeterResourceState:
     def __init__(__self__, *,
+                 access_policy_id: Optional[pulumi.Input[str]] = None,
+                 etag: Optional[pulumi.Input[str]] = None,
                  perimeter_name: Optional[pulumi.Input[str]] = None,
                  resource: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering ServicePerimeterResource resources.
+        :param pulumi.Input[str] access_policy_id: The name of the Access Policy this resource belongs to.
+        :param pulumi.Input[str] etag: The perimeter etag is internally used to prevent overwriting the list of perimeter resources on PATCH calls. It is retrieved from the same GET perimeter API call that's used to get the current list of resources. The resource to add or remove is merged into that list and then this etag is sent with the PATCH call along with the updated resource list.
         :param pulumi.Input[str] perimeter_name: The name of the Service Perimeter to add this resource to.
                
                
@@ -79,11 +83,39 @@ class _ServicePerimeterResourceState:
                Currently only projects are allowed.
                Format: projects/{project_number}
         """
+        if access_policy_id is not None:
+            pulumi.set(__self__, "access_policy_id", access_policy_id)
+        if etag is not None:
+            pulumi.set(__self__, "etag", etag)
         if perimeter_name is not None:
             pulumi.set(__self__, "perimeter_name", perimeter_name)
         if resource is not None:
             pulumi.set(__self__, "resource", resource)
 
+    @property
+    @pulumi.getter(name="accessPolicyId")
+    def access_policy_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the Access Policy this resource belongs to.
+        """
+        return pulumi.get(self, "access_policy_id")
+
+    @access_policy_id.setter
+    def access_policy_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "access_policy_id", value)
+
+    @property
+    @pulumi.getter
+    def etag(self) -> Optional[pulumi.Input[str]]:
+        """
+        The perimeter etag is internally used to prevent overwriting the list of perimeter resources on PATCH calls. It is retrieved from the same GET perimeter API call that's used to get the current list of resources. The resource to add or remove is merged into that list and then this etag is sent with the PATCH call along with the updated resource list.
+        """
+        return pulumi.get(self, "etag")
+
+    @etag.setter
+    def etag(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "etag", value)
+
     @property
     @pulumi.getter(name="perimeterName")
     def perimeter_name(self) -> Optional[pulumi.Input[str]]:
@@ -286,6 +318,8 @@ class ServicePerimeterResource(pulumi.CustomResource):
             if resource is None and not opts.urn:
                 raise TypeError("Missing required property 'resource'")
             __props__.__dict__["resource"] = resource
+            __props__.__dict__["access_policy_id"] = None
+            __props__.__dict__["etag"] = None
         super(ServicePerimeterResource, __self__).__init__(
             'gcp:accesscontextmanager/servicePerimeterResource:ServicePerimeterResource',
             resource_name,
@@ -296,6 +330,8 @@ class ServicePerimeterResource(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            access_policy_id: Optional[pulumi.Input[str]] = None,
+            etag: Optional[pulumi.Input[str]] = None,
             perimeter_name: Optional[pulumi.Input[str]] = None,
             resource: Optional[pulumi.Input[str]] = None) -> 'ServicePerimeterResource':
         """
@@ -305,6 +341,8 @@ class ServicePerimeterResource(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] access_policy_id: The name of the Access Policy this resource belongs to.
+        :param pulumi.Input[str] etag: The perimeter etag is internally used to prevent overwriting the list of perimeter resources on PATCH calls. It is retrieved from the same GET perimeter API call that's used to get the current list of resources. The resource to add or remove is merged into that list and then this etag is sent with the PATCH call along with the updated resource list.
         :param pulumi.Input[str] perimeter_name: The name of the Service Perimeter to add this resource to.
                
                
@@ -317,10 +355,28 @@ class ServicePerimeterResource(pulumi.CustomResource):
 
         __props__ = _ServicePerimeterResourceState.__new__(_ServicePerimeterResourceState)
 
+        __props__.__dict__["access_policy_id"] = access_policy_id
+        __props__.__dict__["etag"] = etag
         __props__.__dict__["perimeter_name"] = perimeter_name
         __props__.__dict__["resource"] = resource
         return ServicePerimeterResource(resource_name, opts=opts, __props__=__props__)
 
+    @property
+    @pulumi.getter(name="accessPolicyId")
+    def access_policy_id(self) -> pulumi.Output[str]:
+        """
+        The name of the Access Policy this resource belongs to.
+        """
+        return pulumi.get(self, "access_policy_id")
+
+    @property
+    @pulumi.getter
+    def etag(self) -> pulumi.Output[str]:
+        """
+        The perimeter etag is internally used to prevent overwriting the list of perimeter resources on PATCH calls. It is retrieved from the same GET perimeter API call that's used to get the current list of resources. The resource to add or remove is merged into that list and then this etag is sent with the PATCH call along with the updated resource list.
+        """
+        return pulumi.get(self, "etag")
+
     @property
     @pulumi.getter(name="perimeterName")
     def perimeter_name(self) -> pulumi.Output[str]:

pulumi_gcp/apigee/__init__.py

@@ -15,6 +15,7 @@ from .env_group_attachment import *
 from .env_keystore import *
 from .env_references import *
 from .environment import *
+from .environment_addons_config import *
 from .environment_iam_binding import *
 from .environment_iam_member import *
 from .environment_iam_policy import *

pulumi_gcp/apigee/environment_addons_config.py

@@ -0,0 +1,266 @@
+# 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__ = ['EnvironmentAddonsConfigArgs', 'EnvironmentAddonsConfig']
+
+@pulumi.input_type
+class EnvironmentAddonsConfigArgs:
+    def __init__(__self__, *,
+                 env_id: pulumi.Input[str],
+                 analytics_enabled: Optional[pulumi.Input[bool]] = None):
+        """
+        The set of arguments for constructing a EnvironmentAddonsConfig resource.
+        :param pulumi.Input[str] env_id: The Apigee environment group associated with the Apigee environment,
+               in the format `organizations/{{org_name}}/environments/{{env_name}}`.
+               
+               
+               - - -
+        :param pulumi.Input[bool] analytics_enabled: Flag to enable/disable Analytics.
+        """
+        pulumi.set(__self__, "env_id", env_id)
+        if analytics_enabled is not None:
+            pulumi.set(__self__, "analytics_enabled", analytics_enabled)
+
+    @property
+    @pulumi.getter(name="envId")
+    def env_id(self) -> pulumi.Input[str]:
+        """
+        The Apigee environment group associated with the Apigee environment,
+        in the format `organizations/{{org_name}}/environments/{{env_name}}`.
+
+
+        - - -
+        """
+        return pulumi.get(self, "env_id")
+
+    @env_id.setter
+    def env_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "env_id", value)
+
+    @property
+    @pulumi.getter(name="analyticsEnabled")
+    def analytics_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Flag to enable/disable Analytics.
+        """
+        return pulumi.get(self, "analytics_enabled")
+
+    @analytics_enabled.setter
+    def analytics_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "analytics_enabled", value)
+
+
+@pulumi.input_type
+class _EnvironmentAddonsConfigState:
+    def __init__(__self__, *,
+                 analytics_enabled: Optional[pulumi.Input[bool]] = None,
+                 env_id: Optional[pulumi.Input[str]] = None):
+        """
+        Input properties used for looking up and filtering EnvironmentAddonsConfig resources.
+        :param pulumi.Input[bool] analytics_enabled: Flag to enable/disable Analytics.
+        :param pulumi.Input[str] env_id: The Apigee environment group associated with the Apigee environment,
+               in the format `organizations/{{org_name}}/environments/{{env_name}}`.
+               
+               
+               - - -
+        """
+        if analytics_enabled is not None:
+            pulumi.set(__self__, "analytics_enabled", analytics_enabled)
+        if env_id is not None:
+            pulumi.set(__self__, "env_id", env_id)
+
+    @property
+    @pulumi.getter(name="analyticsEnabled")
+    def analytics_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Flag to enable/disable Analytics.
+        """
+        return pulumi.get(self, "analytics_enabled")
+
+    @analytics_enabled.setter
+    def analytics_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "analytics_enabled", value)
+
+    @property
+    @pulumi.getter(name="envId")
+    def env_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The Apigee environment group associated with the Apigee environment,
+        in the format `organizations/{{org_name}}/environments/{{env_name}}`.
+
+
+        - - -
+        """
+        return pulumi.get(self, "env_id")
+
+    @env_id.setter
+    def env_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "env_id", value)
+
+
+class EnvironmentAddonsConfig(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 analytics_enabled: Optional[pulumi.Input[bool]] = None,
+                 env_id: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        """
+        Enable/Disable add-ons for an Apigee environment.
+
+        To get more information about EnvironmentAddonsConfig, see:
+
+        * [API documentation](https://cloud.google.com/apigee/docs/reference/apis/apigee/rest/v1/organizations.environments.addonsConfig/setAddonEnablement)
+        * How-to Guides
+            * [Enable Analytics Add-On](https://cloud.google.com/apigee/docs/api-platform/reference/manage-analytics-add-on)
+
+        ## Example Usage
+
+        ## Import
+
+        EnvironmentAddonsConfig can be imported using any of these accepted formats:
+
+        * `{{env_id}}`
+
+        When using the `pulumi import` command, EnvironmentAddonsConfig can be imported using one of the formats above. For example:
+
+        ```sh
+        $ pulumi import gcp:apigee/environmentAddonsConfig:EnvironmentAddonsConfig default {{env_id}}
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[bool] analytics_enabled: Flag to enable/disable Analytics.
+        :param pulumi.Input[str] env_id: The Apigee environment group associated with the Apigee environment,
+               in the format `organizations/{{org_name}}/environments/{{env_name}}`.
+               
+               
+               - - -
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: EnvironmentAddonsConfigArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Enable/Disable add-ons for an Apigee environment.
+
+        To get more information about EnvironmentAddonsConfig, see:
+
+        * [API documentation](https://cloud.google.com/apigee/docs/reference/apis/apigee/rest/v1/organizations.environments.addonsConfig/setAddonEnablement)
+        * How-to Guides
+            * [Enable Analytics Add-On](https://cloud.google.com/apigee/docs/api-platform/reference/manage-analytics-add-on)
+
+        ## Example Usage
+
+        ## Import
+
+        EnvironmentAddonsConfig can be imported using any of these accepted formats:
+
+        * `{{env_id}}`
+
+        When using the `pulumi import` command, EnvironmentAddonsConfig can be imported using one of the formats above. For example:
+
+        ```sh
+        $ pulumi import gcp:apigee/environmentAddonsConfig:EnvironmentAddonsConfig default {{env_id}}
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param EnvironmentAddonsConfigArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(EnvironmentAddonsConfigArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 analytics_enabled: Optional[pulumi.Input[bool]] = None,
+                 env_id: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = EnvironmentAddonsConfigArgs.__new__(EnvironmentAddonsConfigArgs)
+
+            __props__.__dict__["analytics_enabled"] = analytics_enabled
+            if env_id is None and not opts.urn:
+                raise TypeError("Missing required property 'env_id'")
+            __props__.__dict__["env_id"] = env_id
+        super(EnvironmentAddonsConfig, __self__).__init__(
+            'gcp:apigee/environmentAddonsConfig:EnvironmentAddonsConfig',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            analytics_enabled: Optional[pulumi.Input[bool]] = None,
+            env_id: Optional[pulumi.Input[str]] = None) -> 'EnvironmentAddonsConfig':
+        """
+        Get an existing EnvironmentAddonsConfig resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[bool] analytics_enabled: Flag to enable/disable Analytics.
+        :param pulumi.Input[str] env_id: The Apigee environment group associated with the Apigee environment,
+               in the format `organizations/{{org_name}}/environments/{{env_name}}`.
+               
+               
+               - - -
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _EnvironmentAddonsConfigState.__new__(_EnvironmentAddonsConfigState)
+
+        __props__.__dict__["analytics_enabled"] = analytics_enabled
+        __props__.__dict__["env_id"] = env_id
+        return EnvironmentAddonsConfig(resource_name, opts=opts, __props__=__props__)
+
+    @property
+    @pulumi.getter(name="analyticsEnabled")
+    def analytics_enabled(self) -> pulumi.Output[Optional[bool]]:
+        """
+        Flag to enable/disable Analytics.
+        """
+        return pulumi.get(self, "analytics_enabled")
+
+    @property
+    @pulumi.getter(name="envId")
+    def env_id(self) -> pulumi.Output[str]:
+        """
+        The Apigee environment group associated with the Apigee environment,
+        in the format `organizations/{{org_name}}/environments/{{env_name}}`.
+
+
+        - - -
+        """
+        return pulumi.get(self, "env_id")
+

pulumi_gcp/artifactregistry/repository.py

@@ -947,6 +947,21 @@ class Repository(pulumi.CustomResource):
             format="DOCKER",
             cleanup_policy_dry_run=False,
             cleanup_policies=[
+                {
+                    "id": "delete-untagged",
+                    "action": "DELETE",
+                    "condition": {
+                        "tag_state": "UNTAGGED",
+                    },
+                },
+                {
+                    "id": "keep-new-untagged",
+                    "action": "KEEP",
+                    "condition": {
+                        "tag_state": "UNTAGGED",
+                        "newer_than": "7d",
+                    },
+                },
                 {
                     "id": "delete-prerelease",
                     "action": "DELETE",
@@ -956,7 +971,7 @@ class Repository(pulumi.CustomResource):
                             "alpha",
                             "v0",
                         ],
-                        "older_than": "2592000s",
+                        "older_than": "30d",
                     },
                 },
                 {
@@ -1560,6 +1575,21 @@ class Repository(pulumi.CustomResource):
             format="DOCKER",
             cleanup_policy_dry_run=False,
             cleanup_policies=[
+                {
+                    "id": "delete-untagged",
+                    "action": "DELETE",
+                    "condition": {
+                        "tag_state": "UNTAGGED",
+                    },
+                },
+                {
+                    "id": "keep-new-untagged",
+                    "action": "KEEP",
+                    "condition": {
+                        "tag_state": "UNTAGGED",
+                        "newer_than": "7d",
+                    },
+                },
                 {
                     "id": "delete-prerelease",
                     "action": "DELETE",
@@ -1569,7 +1599,7 @@ class Repository(pulumi.CustomResource):
                             "alpha",
                             "v0",
                         ],
-                        "older_than": "2592000s",
+                        "older_than": "30d",
                     },
                 },
                 {

pulumi_gcp/bigquery/connection.py

@@ -750,7 +750,7 @@ class Connection(pulumi.CustomResource):
         user = gcp.sql.User("user",
             name="user",
             instance=instance.name,
-            password="tf-test-my-password_77884")
+            password="tf-test-my-password_15222")
         bq_sa = gcp.bigquery.get_default_service_account()
         key_sa_user = gcp.kms.CryptoKeyIAMMember("key_sa_user",
             crypto_key_id="projects/project/locations/us-central1/keyRings/us-central1/cryptoKeys/bq-key",
@@ -1056,7 +1056,7 @@ class Connection(pulumi.CustomResource):
         user = gcp.sql.User("user",
             name="user",
             instance=instance.name,
-            password="tf-test-my-password_77884")
+            password="tf-test-my-password_15222")
         bq_sa = gcp.bigquery.get_default_service_account()
         key_sa_user = gcp.kms.CryptoKeyIAMMember("key_sa_user",
             crypto_key_id="projects/project/locations/us-central1/keyRings/us-central1/cryptoKeys/bq-key",

pulumi_gcp/bigquery/routine.py

@@ -845,7 +845,7 @@ class Routine(pulumi.CustomResource):
         import pulumi
         import pulumi_gcp as gcp
 
-        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_15222")
+        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_81126")
         custom_masking_routine = gcp.bigquery.Routine("custom_masking_routine",
             dataset_id=test.dataset_id,
             routine_id="custom_masking_routine",
@@ -1140,7 +1140,7 @@ class Routine(pulumi.CustomResource):
         import pulumi
         import pulumi_gcp as gcp
 
-        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_15222")
+        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_81126")
         custom_masking_routine = gcp.bigquery.Routine("custom_masking_routine",
             dataset_id=test.dataset_id,
             routine_id="custom_masking_routine",