pulumi-aws 7.15.0__py3-none-any.whl → 7.16.0__py3-none-any.whl

pulumi_aws/ec2/outputs.py

@@ -17280,6 +17280,10 @@ class VpcEndpointDnsOptions(dict):
             suggest = "dns_record_ip_type"
         elif key == "privateDnsOnlyForInboundResolverEndpoint":
             suggest = "private_dns_only_for_inbound_resolver_endpoint"
+        elif key == "privateDnsPreference":
+            suggest = "private_dns_preference"
+        elif key == "privateDnsSpecifiedDomains":
+            suggest = "private_dns_specified_domains"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in VpcEndpointDnsOptions. Access the value via the '{suggest}' property getter instead.")
@@ -17294,15 +17298,23 @@ class VpcEndpointDnsOptions(dict):
 
     def __init__(__self__, *,
                  dns_record_ip_type: Optional[_builtins.str] = None,
-                 private_dns_only_for_inbound_resolver_endpoint: Optional[_builtins.bool] = None):
+                 private_dns_only_for_inbound_resolver_endpoint: Optional[_builtins.bool] = None,
+                 private_dns_preference: Optional[_builtins.str] = None,
+                 private_dns_specified_domains: Optional[Sequence[_builtins.str]] = None):
         """
         :param _builtins.str dns_record_ip_type: The DNS records created for the endpoint. Valid values are `ipv4`, `dualstack`, `service-defined`, and `ipv6`.
-        :param _builtins.bool private_dns_only_for_inbound_resolver_endpoint: Indicates whether to enable private DNS only for inbound endpoints. This option is available only for services that support both gateway and interface endpoints. It routes traffic that originates from the VPC to the gateway endpoint and traffic that originates from on-premises to the interface endpoint. Default is `false`. Can only be specified if private_dns_enabled is `true`.
+        :param _builtins.bool private_dns_only_for_inbound_resolver_endpoint: Boolean indicating whether to enable private DNS only for inbound endpoints. This option is available only for interface endpoints of services that support both gateway and interface endpoints. A gateway endpoint for the same service must be created before an interface endpoint is created. Traffic originating from the VPC is routed to the gateway endpoint, while traffic originating from on-premises is routed to the interface endpoint. Defaults to `false`. This argument can be specified only if `private_dns_enabled` is `true`.
+        :param _builtins.str private_dns_preference: Preference for which private domains have a private hosted zone created for and associated with the specified VPC. Valid values are `ALL_DOMAINS`, `VERIFIED_DOMAINS_ONLY`, `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS`, and `SPECIFIED_DOMAINS_ONLY`. Only supported when `private_dns_enabled` is `true` and when the `vpc_endpoint_type` is `ServiceNetwork` or `Resource`.
+        :param Sequence[_builtins.str] private_dns_specified_domains: List of private domains to create private hosted zones for and associate with the specified VPC. Must be specified when `private_dns_enabled` is `true` and `private_dns_preference` is set to either `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS` or `SPECIFIED_DOMAINS_ONLY`. In all other cases, this argument must not be specified.
         """
         if dns_record_ip_type is not None:
             pulumi.set(__self__, "dns_record_ip_type", dns_record_ip_type)
         if private_dns_only_for_inbound_resolver_endpoint is not None:
             pulumi.set(__self__, "private_dns_only_for_inbound_resolver_endpoint", private_dns_only_for_inbound_resolver_endpoint)
+        if private_dns_preference is not None:
+            pulumi.set(__self__, "private_dns_preference", private_dns_preference)
+        if private_dns_specified_domains is not None:
+            pulumi.set(__self__, "private_dns_specified_domains", private_dns_specified_domains)
 
     @_builtins.property
     @pulumi.getter(name="dnsRecordIpType")
@@ -17316,10 +17328,26 @@ class VpcEndpointDnsOptions(dict):
     @pulumi.getter(name="privateDnsOnlyForInboundResolverEndpoint")
     def private_dns_only_for_inbound_resolver_endpoint(self) -> Optional[_builtins.bool]:
         """
-        Indicates whether to enable private DNS only for inbound endpoints. This option is available only for services that support both gateway and interface endpoints. It routes traffic that originates from the VPC to the gateway endpoint and traffic that originates from on-premises to the interface endpoint. Default is `false`. Can only be specified if private_dns_enabled is `true`.
+        Boolean indicating whether to enable private DNS only for inbound endpoints. This option is available only for interface endpoints of services that support both gateway and interface endpoints. A gateway endpoint for the same service must be created before an interface endpoint is created. Traffic originating from the VPC is routed to the gateway endpoint, while traffic originating from on-premises is routed to the interface endpoint. Defaults to `false`. This argument can be specified only if `private_dns_enabled` is `true`.
         """
         return pulumi.get(self, "private_dns_only_for_inbound_resolver_endpoint")
 
+    @_builtins.property
+    @pulumi.getter(name="privateDnsPreference")
+    def private_dns_preference(self) -> Optional[_builtins.str]:
+        """
+        Preference for which private domains have a private hosted zone created for and associated with the specified VPC. Valid values are `ALL_DOMAINS`, `VERIFIED_DOMAINS_ONLY`, `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS`, and `SPECIFIED_DOMAINS_ONLY`. Only supported when `private_dns_enabled` is `true` and when the `vpc_endpoint_type` is `ServiceNetwork` or `Resource`.
+        """
+        return pulumi.get(self, "private_dns_preference")
+
+    @_builtins.property
+    @pulumi.getter(name="privateDnsSpecifiedDomains")
+    def private_dns_specified_domains(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        List of private domains to create private hosted zones for and associate with the specified VPC. Must be specified when `private_dns_enabled` is `true` and `private_dns_preference` is set to either `VERIFIED_DOMAINS_AND_SPECIFIED_DOMAINS` or `SPECIFIED_DOMAINS_ONLY`. In all other cases, this argument must not be specified.
+        """
+        return pulumi.get(self, "private_dns_specified_domains")
+
 
 @pulumi.output_type
 class VpcEndpointServicePrivateDnsNameConfiguration(dict):
@@ -25487,13 +25515,19 @@ class GetVpcEndpointDnsEntryResult(dict):
 class GetVpcEndpointDnsOptionResult(dict):
     def __init__(__self__, *,
                  dns_record_ip_type: _builtins.str,
-                 private_dns_only_for_inbound_resolver_endpoint: _builtins.bool):
+                 private_dns_only_for_inbound_resolver_endpoint: _builtins.bool,
+                 private_dns_preference: _builtins.str,
+                 private_dns_specified_domains: Sequence[_builtins.str]):
         """
         :param _builtins.str dns_record_ip_type: The DNS records created for the endpoint.
         :param _builtins.bool private_dns_only_for_inbound_resolver_endpoint: Indicates whether to enable private DNS only for inbound endpoints.
+        :param _builtins.str private_dns_preference: Preference for which private domains have a private hosted zone created for and associated with the specified VPC.
+        :param Sequence[_builtins.str] private_dns_specified_domains: List of private domains to create private hosted zones for and associate with the specified VPC.
         """
         pulumi.set(__self__, "dns_record_ip_type", dns_record_ip_type)
         pulumi.set(__self__, "private_dns_only_for_inbound_resolver_endpoint", private_dns_only_for_inbound_resolver_endpoint)
+        pulumi.set(__self__, "private_dns_preference", private_dns_preference)
+        pulumi.set(__self__, "private_dns_specified_domains", private_dns_specified_domains)
 
     @_builtins.property
     @pulumi.getter(name="dnsRecordIpType")
@@ -25511,6 +25545,22 @@ class GetVpcEndpointDnsOptionResult(dict):
         """
         return pulumi.get(self, "private_dns_only_for_inbound_resolver_endpoint")
 
+    @_builtins.property
+    @pulumi.getter(name="privateDnsPreference")
+    def private_dns_preference(self) -> _builtins.str:
+        """
+        Preference for which private domains have a private hosted zone created for and associated with the specified VPC.
+        """
+        return pulumi.get(self, "private_dns_preference")
+
+    @_builtins.property
+    @pulumi.getter(name="privateDnsSpecifiedDomains")
+    def private_dns_specified_domains(self) -> Sequence[_builtins.str]:
+        """
+        List of private domains to create private hosted zones for and associate with the specified VPC.
+        """
+        return pulumi.get(self, "private_dns_specified_domains")
+
 
 @pulumi.output_type
 class GetVpcEndpointFilterResult(dict):

pulumi_aws/ecr/__init__.py

@@ -18,6 +18,7 @@ from .get_repository import *
 from .get_repository_creation_template import *
 from .lifecycle_policy import *
 from .pull_through_cache_rule import *
+from .pull_time_update_exclusion import *
 from .registry_policy import *
 from .registry_scanning_configuration import *
 from .replication_configuration import *

pulumi_aws/ecr/_inputs.py

@@ -890,11 +890,11 @@ if not MYPY:
     class GetLifecyclePolicyDocumentRuleArgsDict(TypedDict):
         priority: _builtins.int
         """
-        Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tag_status` value of "any" must have the highest value for `priority` and be evaluated last.
+        Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tag_status` value of `any` must have the highest value for `priority` and be evaluated last.
         """
         action: NotRequired['GetLifecyclePolicyDocumentRuleActionArgsDict']
         """
-        Specifies the action type.
+        Specifies the action to take.
         """
         description: NotRequired[_builtins.str]
         """
@@ -915,8 +915,8 @@ class GetLifecyclePolicyDocumentRuleArgs:
                  description: Optional[_builtins.str] = None,
                  selection: Optional['GetLifecyclePolicyDocumentRuleSelectionArgs'] = None):
         """
-        :param _builtins.int priority: Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tag_status` value of "any" must have the highest value for `priority` and be evaluated last.
-        :param 'GetLifecyclePolicyDocumentRuleActionArgs' action: Specifies the action type.
+        :param _builtins.int priority: Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tag_status` value of `any` must have the highest value for `priority` and be evaluated last.
+        :param 'GetLifecyclePolicyDocumentRuleActionArgs' action: Specifies the action to take.
         :param _builtins.str description: Describes the purpose of a rule within a lifecycle policy.
         :param 'GetLifecyclePolicyDocumentRuleSelectionArgs' selection: Collects parameters describing the selection criteria for the ECR lifecycle policy:
         """
@@ -932,7 +932,7 @@ class GetLifecyclePolicyDocumentRuleArgs:
     @pulumi.getter
     def priority(self) -> _builtins.int:
         """
-        Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tag_status` value of "any" must have the highest value for `priority` and be evaluated last.
+        Sets the order in which rules are evaluated, lowest to highest. When you add rules to a lifecycle policy, you must give them each a unique value for `priority`. Values do not need to be sequential across rules in a policy. A rule with a `tag_status` value of `any` must have the highest value for `priority` and be evaluated last.
         """
         return pulumi.get(self, "priority")
 
@@ -944,7 +944,7 @@ class GetLifecyclePolicyDocumentRuleArgs:
     @pulumi.getter
     def action(self) -> Optional['GetLifecyclePolicyDocumentRuleActionArgs']:
         """
-        Specifies the action type.
+        Specifies the action to take.
         """
         return pulumi.get(self, "action")
 
@@ -981,25 +981,32 @@ if not MYPY:
     class GetLifecyclePolicyDocumentRuleActionArgsDict(TypedDict):
         type: _builtins.str
         """
-        The supported value is `expire`.
+        Specify an action type. The supported values are `expire` (to delete images) and `transition` (to move images to archive storage).
+        * `targetStorageClass` (Required if `type` is `transition`) - The storage class you want the lifecycle policy to transition the image to. `archive` is the only supported value.
         """
+        target_storage_class: NotRequired[_builtins.str]
 elif False:
     GetLifecyclePolicyDocumentRuleActionArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class GetLifecyclePolicyDocumentRuleActionArgs:
     def __init__(__self__, *,
-                 type: _builtins.str):
+                 type: _builtins.str,
+                 target_storage_class: Optional[_builtins.str] = None):
         """
-        :param _builtins.str type: The supported value is `expire`.
+        :param _builtins.str type: Specify an action type. The supported values are `expire` (to delete images) and `transition` (to move images to archive storage).
+               * `targetStorageClass` (Required if `type` is `transition`) - The storage class you want the lifecycle policy to transition the image to. `archive` is the only supported value.
         """
         pulumi.set(__self__, "type", type)
+        if target_storage_class is not None:
+            pulumi.set(__self__, "target_storage_class", target_storage_class)
 
     @_builtins.property
     @pulumi.getter
     def type(self) -> _builtins.str:
         """
-        The supported value is `expire`.
+        Specify an action type. The supported values are `expire` (to delete images) and `transition` (to move images to archive storage).
+        * `targetStorageClass` (Required if `type` is `transition`) - The storage class you want the lifecycle policy to transition the image to. `archive` is the only supported value.
         """
         return pulumi.get(self, "type")
 
@@ -1007,24 +1014,37 @@ class GetLifecyclePolicyDocumentRuleActionArgs:
     def type(self, value: _builtins.str):
         pulumi.set(self, "type", value)
 
+    @_builtins.property
+    @pulumi.getter(name="targetStorageClass")
+    def target_storage_class(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "target_storage_class")
+
+    @target_storage_class.setter
+    def target_storage_class(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "target_storage_class", value)
+
 
 if not MYPY:
     class GetLifecyclePolicyDocumentRuleSelectionArgsDict(TypedDict):
         count_number: _builtins.int
         """
-        Specify a count number. If the `count_type` used is "imageCountMoreThan", then the value is the maximum number of images that you want to retain in your repository. If the `count_type` used is "sinceImagePushed", then the value is the maximum age limit for your images.
+        Specify a count number. If the `count_type` used is `imageCountMoreThan`, then the value is the maximum number of images that you want to retain in your repository. If the `count_type` used is `sinceImagePushed`, then the value is the maximum age limit for your images. If the `count_type` used is `sinceImagePulled`, then the value is the maximum number of days since the image was last pulled. If the `count_type` used is `sinceImageTransitioned`, then the value is the maximum number of days since the image was archived.
         """
         count_type: _builtins.str
         """
-        Specify a count type to apply to the images. If `count_type` is set to "imageCountMoreThan", you also specify `count_number` to create a rule that sets a limit on the number of images that exist in your repository. If `count_type` is set to "sinceImagePushed", you also specify `count_unit` and `count_number` to specify a time limit on the images that exist in your repository.
+        Specify a count type to apply to the images. If `count_type` is set to `imageCountMoreThan`, you also specify `count_number` to create a rule that sets a limit on the number of images that exist in your repository. If `count_type` is set to `sinceImagePushed`, `sinceImagePulled`, or `sinceImageTransitioned`, you also specify `count_unit` and `count_number` to specify a time limit on the images that exist in your repository.
         """
         tag_status: _builtins.str
         """
-        Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are "tagged", "untagged", or "any". If you specify "any", then all images have the rule applied to them. If you specify "tagged", then you must also specify a `tag_prefix_list` value. If you specify "untagged", then you must omit `tag_prefix_list`.
+        Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are `tagged`, `untagged`, or `any`. If you specify `any`, then all images have the rule evaluated against them. If you specify `tagged`, then you must also specify a `tag_prefix_list` value or a `tag_pattern_list` value. If you specify `untagged`, then you must omit both `tag_prefix_list` and `tag_pattern_list`.
         """
         count_unit: NotRequired[_builtins.str]
         """
-        Specify a count unit of days to indicate that as the unit of time, in addition to `count_number`, which is the number of days.
+        Specify a count unit of `days` to indicate that as the unit of time, in addition to `count_number`, which is the number of days.
+        """
+        storage_class: NotRequired[_builtins.str]
+        """
+        The rule will only select images of this storage class. When using a `count_type` of `imageCountMoreThan`, `sinceImagePushed`, or `sinceImagePulled`, the only supported value is `standard`. When using a `count_type` of `sinceImageTransitioned`, this is required, and the only supported value is `archive`. If you omit this, the value of `standard` will be used.
         """
         tag_pattern_lists: NotRequired[Sequence[_builtins.str]]
         """
@@ -1044,13 +1064,15 @@ class GetLifecyclePolicyDocumentRuleSelectionArgs:
                  count_type: _builtins.str,
                  tag_status: _builtins.str,
                  count_unit: Optional[_builtins.str] = None,
+                 storage_class: Optional[_builtins.str] = None,
                  tag_pattern_lists: Optional[Sequence[_builtins.str]] = None,
                  tag_prefix_lists: Optional[Sequence[_builtins.str]] = None):
         """
-        :param _builtins.int count_number: Specify a count number. If the `count_type` used is "imageCountMoreThan", then the value is the maximum number of images that you want to retain in your repository. If the `count_type` used is "sinceImagePushed", then the value is the maximum age limit for your images.
-        :param _builtins.str count_type: Specify a count type to apply to the images. If `count_type` is set to "imageCountMoreThan", you also specify `count_number` to create a rule that sets a limit on the number of images that exist in your repository. If `count_type` is set to "sinceImagePushed", you also specify `count_unit` and `count_number` to specify a time limit on the images that exist in your repository.
-        :param _builtins.str tag_status: Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are "tagged", "untagged", or "any". If you specify "any", then all images have the rule applied to them. If you specify "tagged", then you must also specify a `tag_prefix_list` value. If you specify "untagged", then you must omit `tag_prefix_list`.
-        :param _builtins.str count_unit: Specify a count unit of days to indicate that as the unit of time, in addition to `count_number`, which is the number of days.
+        :param _builtins.int count_number: Specify a count number. If the `count_type` used is `imageCountMoreThan`, then the value is the maximum number of images that you want to retain in your repository. If the `count_type` used is `sinceImagePushed`, then the value is the maximum age limit for your images. If the `count_type` used is `sinceImagePulled`, then the value is the maximum number of days since the image was last pulled. If the `count_type` used is `sinceImageTransitioned`, then the value is the maximum number of days since the image was archived.
+        :param _builtins.str count_type: Specify a count type to apply to the images. If `count_type` is set to `imageCountMoreThan`, you also specify `count_number` to create a rule that sets a limit on the number of images that exist in your repository. If `count_type` is set to `sinceImagePushed`, `sinceImagePulled`, or `sinceImageTransitioned`, you also specify `count_unit` and `count_number` to specify a time limit on the images that exist in your repository.
+        :param _builtins.str tag_status: Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are `tagged`, `untagged`, or `any`. If you specify `any`, then all images have the rule evaluated against them. If you specify `tagged`, then you must also specify a `tag_prefix_list` value or a `tag_pattern_list` value. If you specify `untagged`, then you must omit both `tag_prefix_list` and `tag_pattern_list`.
+        :param _builtins.str count_unit: Specify a count unit of `days` to indicate that as the unit of time, in addition to `count_number`, which is the number of days.
+        :param _builtins.str storage_class: The rule will only select images of this storage class. When using a `count_type` of `imageCountMoreThan`, `sinceImagePushed`, or `sinceImagePulled`, the only supported value is `standard`. When using a `count_type` of `sinceImageTransitioned`, this is required, and the only supported value is `archive`. If you omit this, the value of `standard` will be used.
         :param Sequence[_builtins.str] tag_pattern_lists: You must specify a comma-separated list of image tag patterns that may contain wildcards (\\*) on which to take action with your lifecycle policy. For example, if your images are tagged as `prod`, `prod1`, `prod2`, and so on, you would use the tag pattern list `["prod\\*"]` to specify all of them. If you specify multiple tags, only the images with all specified tags are selected. There is a maximum limit of four wildcards (\\*) per string. For example, `["*test*1*2*3", "test*1*2*3*"]` is valid but `["test*1*2*3*4*5*6"]` is invalid.
         :param Sequence[_builtins.str] tag_prefix_lists: You must specify a comma-separated list of image tag prefixes on which to take action with your lifecycle policy. For example, if your images are tagged as `prod`, `prod1`, `prod2`, and so on, you would use the tag prefix "prod" to specify all of them. If you specify multiple tags, only images with all specified tags are selected.
         """
@@ -1059,6 +1081,8 @@ class GetLifecyclePolicyDocumentRuleSelectionArgs:
         pulumi.set(__self__, "tag_status", tag_status)
         if count_unit is not None:
             pulumi.set(__self__, "count_unit", count_unit)
+        if storage_class is not None:
+            pulumi.set(__self__, "storage_class", storage_class)
         if tag_pattern_lists is not None:
             pulumi.set(__self__, "tag_pattern_lists", tag_pattern_lists)
         if tag_prefix_lists is not None:
@@ -1068,7 +1092,7 @@ class GetLifecyclePolicyDocumentRuleSelectionArgs:
     @pulumi.getter(name="countNumber")
     def count_number(self) -> _builtins.int:
         """
-        Specify a count number. If the `count_type` used is "imageCountMoreThan", then the value is the maximum number of images that you want to retain in your repository. If the `count_type` used is "sinceImagePushed", then the value is the maximum age limit for your images.
+        Specify a count number. If the `count_type` used is `imageCountMoreThan`, then the value is the maximum number of images that you want to retain in your repository. If the `count_type` used is `sinceImagePushed`, then the value is the maximum age limit for your images. If the `count_type` used is `sinceImagePulled`, then the value is the maximum number of days since the image was last pulled. If the `count_type` used is `sinceImageTransitioned`, then the value is the maximum number of days since the image was archived.
         """
         return pulumi.get(self, "count_number")
 
@@ -1080,7 +1104,7 @@ class GetLifecyclePolicyDocumentRuleSelectionArgs:
     @pulumi.getter(name="countType")
     def count_type(self) -> _builtins.str:
         """
-        Specify a count type to apply to the images. If `count_type` is set to "imageCountMoreThan", you also specify `count_number` to create a rule that sets a limit on the number of images that exist in your repository. If `count_type` is set to "sinceImagePushed", you also specify `count_unit` and `count_number` to specify a time limit on the images that exist in your repository.
+        Specify a count type to apply to the images. If `count_type` is set to `imageCountMoreThan`, you also specify `count_number` to create a rule that sets a limit on the number of images that exist in your repository. If `count_type` is set to `sinceImagePushed`, `sinceImagePulled`, or `sinceImageTransitioned`, you also specify `count_unit` and `count_number` to specify a time limit on the images that exist in your repository.
         """
         return pulumi.get(self, "count_type")
 
@@ -1092,7 +1116,7 @@ class GetLifecyclePolicyDocumentRuleSelectionArgs:
     @pulumi.getter(name="tagStatus")
     def tag_status(self) -> _builtins.str:
         """
-        Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are "tagged", "untagged", or "any". If you specify "any", then all images have the rule applied to them. If you specify "tagged", then you must also specify a `tag_prefix_list` value. If you specify "untagged", then you must omit `tag_prefix_list`.
+        Determines whether the lifecycle policy rule that you are adding specifies a tag for an image. Acceptable options are `tagged`, `untagged`, or `any`. If you specify `any`, then all images have the rule evaluated against them. If you specify `tagged`, then you must also specify a `tag_prefix_list` value or a `tag_pattern_list` value. If you specify `untagged`, then you must omit both `tag_prefix_list` and `tag_pattern_list`.
         """
         return pulumi.get(self, "tag_status")
 
@@ -1104,7 +1128,7 @@ class GetLifecyclePolicyDocumentRuleSelectionArgs:
     @pulumi.getter(name="countUnit")
     def count_unit(self) -> Optional[_builtins.str]:
         """
-        Specify a count unit of days to indicate that as the unit of time, in addition to `count_number`, which is the number of days.
+        Specify a count unit of `days` to indicate that as the unit of time, in addition to `count_number`, which is the number of days.
         """
         return pulumi.get(self, "count_unit")
 
@@ -1112,6 +1136,18 @@ class GetLifecyclePolicyDocumentRuleSelectionArgs:
     def count_unit(self, value: Optional[_builtins.str]):
         pulumi.set(self, "count_unit", value)
 
+    @_builtins.property
+    @pulumi.getter(name="storageClass")
+    def storage_class(self) -> Optional[_builtins.str]:
+        """
+        The rule will only select images of this storage class. When using a `count_type` of `imageCountMoreThan`, `sinceImagePushed`, or `sinceImagePulled`, the only supported value is `standard`. When using a `count_type` of `sinceImageTransitioned`, this is required, and the only supported value is `archive`. If you omit this, the value of `standard` will be used.
+        """
+        return pulumi.get(self, "storage_class")
+
+    @storage_class.setter
+    def storage_class(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "storage_class", value)
+
     @_builtins.property
     @pulumi.getter(name="tagPatternLists")
     def tag_pattern_lists(self) -> Optional[Sequence[_builtins.str]]:

pulumi_aws/ecr/get_repository_creation_template.py

@@ -72,7 +72,7 @@ class GetRepositoryCreationTemplateResult:
     @pulumi.getter(name="appliedFors")
     def applied_fors(self) -> Sequence[_builtins.str]:
         """
-        Which features this template applies to. Contains one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        Which features this template applies to. Contains one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         """
         return pulumi.get(self, "applied_fors")
 

pulumi_aws/ecr/lifecycle_policy.py

@@ -163,7 +163,7 @@ class LifecyclePolicy(pulumi.CustomResource):
 
         ## Example Usage
 
-        ### Policy on untagged image
+        ### Policy on Untagged Images
 
         ```python
         import pulumi
@@ -173,26 +173,26 @@ class LifecyclePolicy(pulumi.CustomResource):
         example_lifecycle_policy = aws.ecr.LifecyclePolicy("example",
             repository=example.name,
             policy=\"\"\"{
-            \\"rules\\": [
-                {
-                    \\"rulePriority\\": 1,
-                    \\"description\\": \\"Expire images older than 14 days\\",
-                    \\"selection\\": {
-                        \\"tagStatus\\": \\"untagged\\",
-                        \\"countType\\": \\"sinceImagePushed\\",
-                        \\"countUnit\\": \\"days\\",
-                        \\"countNumber\\": 14
-                    },
-                    \\"action\\": {
-                        \\"type\\": \\"expire\\"
-                    }
-                }
-            ]
+          \\"rules\\": [
+            {
+              \\"rulePriority\\": 1,
+              \\"description\\": \\"Expire images older than 14 days\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"untagged\\",
+                \\"countType\\": \\"sinceImagePushed\\",
+                \\"countUnit\\": \\"days\\",
+                \\"countNumber\\": 14
+              },
+              \\"action\\": {
+                \\"type\\": \\"expire\\"
+              }
+            }
+          ]
         }
         \"\"\")
         ```
 
-        ### Policy on tagged image
+        ### Policy on Tagged Images
 
         ```python
         import pulumi
@@ -202,21 +202,65 @@ class LifecyclePolicy(pulumi.CustomResource):
         example_lifecycle_policy = aws.ecr.LifecyclePolicy("example",
             repository=example.name,
             policy=\"\"\"{
-            \\"rules\\": [
-                {
-                    \\"rulePriority\\": 1,
-                    \\"description\\": \\"Keep last 30 images\\",
-                    \\"selection\\": {
-                        \\"tagStatus\\": \\"tagged\\",
-                        \\"tagPrefixList\\": [\\"v\\"],
-                        \\"countType\\": \\"imageCountMoreThan\\",
-                        \\"countNumber\\": 30
-                    },
-                    \\"action\\": {
-                        \\"type\\": \\"expire\\"
-                    }
-                }
-            ]
+          \\"rules\\": [
+            {
+              \\"rulePriority\\": 1,
+              \\"description\\": \\"Keep last 30 images\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"tagged\\",
+                \\"tagPrefixList\\": [\\"v\\"],
+                \\"countType\\": \\"imageCountMoreThan\\",
+                \\"countNumber\\": 30
+              },
+              \\"action\\": {
+                \\"type\\": \\"expire\\"
+              }
+            }
+          ]
+        }
+        \"\"\")
+        ```
+
+        ### Policy to Archive and Delete
+
+        ```python
+        import pulumi
+        import pulumi_aws as aws
+
+        example = aws.ecr.Repository("example", name="example-repo")
+        example_lifecycle_policy = aws.ecr.LifecyclePolicy("example",
+            repository=example.name,
+            policy=\"\"\"{
+          \\"rules\\": [
+            {
+              \\"rulePriority\\": 1,
+              \\"description\\": \\"Archive images not pulled in 90 days\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"any\\",
+                \\"countType\\": \\"sinceImagePulled\\",
+                \\"countUnit\\": \\"days\\",
+                \\"countNumber\\": 90
+              },
+              \\"action\\": {
+                \\"type\\": \\"transition\\",
+                \\"targetStorageClass\\": \\"archive\\"
+              }
+            },
+            {
+              \\"rulePriority\\": 2,
+              \\"description\\": \\"Delete images archived for more than 365 days\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"any\\",
+                \\"storageClass\\": \\"archive\\",
+                \\"countType\\": \\"sinceImageTransitioned\\",
+                \\"countUnit\\": \\"days\\",
+                \\"countNumber\\": 365
+              },
+              \\"action\\": {
+                \\"type\\": \\"expire\\"
+              }
+            }
+          ]
         }
         \"\"\")
         ```
@@ -260,7 +304,36 @@ class LifecyclePolicy(pulumi.CustomResource):
 
         ## Example Usage
 
-        ### Policy on untagged image
+        ### Policy on Untagged Images
+
+        ```python
+        import pulumi
+        import pulumi_aws as aws
+
+        example = aws.ecr.Repository("example", name="example-repo")
+        example_lifecycle_policy = aws.ecr.LifecyclePolicy("example",
+            repository=example.name,
+            policy=\"\"\"{
+          \\"rules\\": [
+            {
+              \\"rulePriority\\": 1,
+              \\"description\\": \\"Expire images older than 14 days\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"untagged\\",
+                \\"countType\\": \\"sinceImagePushed\\",
+                \\"countUnit\\": \\"days\\",
+                \\"countNumber\\": 14
+              },
+              \\"action\\": {
+                \\"type\\": \\"expire\\"
+              }
+            }
+          ]
+        }
+        \"\"\")
+        ```
+
+        ### Policy on Tagged Images
 
         ```python
         import pulumi
@@ -270,26 +343,26 @@ class LifecyclePolicy(pulumi.CustomResource):
         example_lifecycle_policy = aws.ecr.LifecyclePolicy("example",
             repository=example.name,
             policy=\"\"\"{
-            \\"rules\\": [
-                {
-                    \\"rulePriority\\": 1,
-                    \\"description\\": \\"Expire images older than 14 days\\",
-                    \\"selection\\": {
-                        \\"tagStatus\\": \\"untagged\\",
-                        \\"countType\\": \\"sinceImagePushed\\",
-                        \\"countUnit\\": \\"days\\",
-                        \\"countNumber\\": 14
-                    },
-                    \\"action\\": {
-                        \\"type\\": \\"expire\\"
-                    }
-                }
-            ]
+          \\"rules\\": [
+            {
+              \\"rulePriority\\": 1,
+              \\"description\\": \\"Keep last 30 images\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"tagged\\",
+                \\"tagPrefixList\\": [\\"v\\"],
+                \\"countType\\": \\"imageCountMoreThan\\",
+                \\"countNumber\\": 30
+              },
+              \\"action\\": {
+                \\"type\\": \\"expire\\"
+              }
+            }
+          ]
         }
         \"\"\")
         ```
 
-        ### Policy on tagged image
+        ### Policy to Archive and Delete
 
         ```python
         import pulumi
@@ -299,21 +372,36 @@ class LifecyclePolicy(pulumi.CustomResource):
         example_lifecycle_policy = aws.ecr.LifecyclePolicy("example",
             repository=example.name,
             policy=\"\"\"{
-            \\"rules\\": [
-                {
-                    \\"rulePriority\\": 1,
-                    \\"description\\": \\"Keep last 30 images\\",
-                    \\"selection\\": {
-                        \\"tagStatus\\": \\"tagged\\",
-                        \\"tagPrefixList\\": [\\"v\\"],
-                        \\"countType\\": \\"imageCountMoreThan\\",
-                        \\"countNumber\\": 30
-                    },
-                    \\"action\\": {
-                        \\"type\\": \\"expire\\"
-                    }
-                }
-            ]
+          \\"rules\\": [
+            {
+              \\"rulePriority\\": 1,
+              \\"description\\": \\"Archive images not pulled in 90 days\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"any\\",
+                \\"countType\\": \\"sinceImagePulled\\",
+                \\"countUnit\\": \\"days\\",
+                \\"countNumber\\": 90
+              },
+              \\"action\\": {
+                \\"type\\": \\"transition\\",
+                \\"targetStorageClass\\": \\"archive\\"
+              }
+            },
+            {
+              \\"rulePriority\\": 2,
+              \\"description\\": \\"Delete images archived for more than 365 days\\",
+              \\"selection\\": {
+                \\"tagStatus\\": \\"any\\",
+                \\"storageClass\\": \\"archive\\",
+                \\"countType\\": \\"sinceImageTransitioned\\",
+                \\"countUnit\\": \\"days\\",
+                \\"countNumber\\": 365
+              },
+              \\"action\\": {
+                \\"type\\": \\"expire\\"
+              }
+            }
+          ]
         }
         \"\"\")
         ```