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

pulumi_aws/ecr/outputs.py

@@ -544,8 +544,8 @@ class GetLifecyclePolicyDocumentRuleResult(dict):
                  description: Optional[_builtins.str] = None,
                  selection: Optional['outputs.GetLifecyclePolicyDocumentRuleSelectionResult'] = 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:
         """
@@ -561,7 +561,7 @@ class GetLifecyclePolicyDocumentRuleResult(dict):
     @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")
 
@@ -569,7 +569,7 @@ class GetLifecyclePolicyDocumentRuleResult(dict):
     @pulumi.getter
     def action(self) -> Optional['outputs.GetLifecyclePolicyDocumentRuleActionResult']:
         """
-        Specifies the action type.
+        Specifies the action to take.
         """
         return pulumi.get(self, "action")
 
@@ -593,20 +593,30 @@ class GetLifecyclePolicyDocumentRuleResult(dict):
 @pulumi.output_type
 class GetLifecyclePolicyDocumentRuleActionResult(dict):
     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")
 
+    @_builtins.property
+    @pulumi.getter(name="targetStorageClass")
+    def target_storage_class(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "target_storage_class")
+
 
 @pulumi.output_type
 class GetLifecyclePolicyDocumentRuleSelectionResult(dict):
@@ -615,13 +625,15 @@ class GetLifecyclePolicyDocumentRuleSelectionResult(dict):
                  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.
         """
@@ -630,6 +642,8 @@ class GetLifecyclePolicyDocumentRuleSelectionResult(dict):
         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:
@@ -639,7 +653,7 @@ class GetLifecyclePolicyDocumentRuleSelectionResult(dict):
     @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")
 
@@ -647,7 +661,7 @@ class GetLifecyclePolicyDocumentRuleSelectionResult(dict):
     @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")
 
@@ -655,7 +669,7 @@ class GetLifecyclePolicyDocumentRuleSelectionResult(dict):
     @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")
 
@@ -663,10 +677,18 @@ class GetLifecyclePolicyDocumentRuleSelectionResult(dict):
     @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")
 
+    @_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")
+
     @_builtins.property
     @pulumi.getter(name="tagPatternLists")
     def tag_pattern_lists(self) -> Optional[Sequence[_builtins.str]]:

pulumi_aws/ecr/pull_time_update_exclusion.py

@@ -0,0 +1,363 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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__ = ['PullTimeUpdateExclusionArgs', 'PullTimeUpdateExclusion']
+
+@pulumi.input_type
+class PullTimeUpdateExclusionArgs:
+    def __init__(__self__, *,
+                 principal_arn: pulumi.Input[_builtins.str],
+                 region: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        The set of arguments for constructing a PullTimeUpdateExclusion resource.
+        :param pulumi.Input[_builtins.str] principal_arn: ARN of the IAM principal to exclude from having image pull times recorded.
+               
+               The following arguments are optional:
+        :param pulumi.Input[_builtins.str] region: Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+        """
+        pulumi.set(__self__, "principal_arn", principal_arn)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+
+    @_builtins.property
+    @pulumi.getter(name="principalArn")
+    def principal_arn(self) -> pulumi.Input[_builtins.str]:
+        """
+        ARN of the IAM principal to exclude from having image pull times recorded.
+
+        The following arguments are optional:
+        """
+        return pulumi.get(self, "principal_arn")
+
+    @principal_arn.setter
+    def principal_arn(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "principal_arn", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+        """
+        return pulumi.get(self, "region")
+
+    @region.setter
+    def region(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "region", value)
+
+
+@pulumi.input_type
+class _PullTimeUpdateExclusionState:
+    def __init__(__self__, *,
+                 principal_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 region: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        Input properties used for looking up and filtering PullTimeUpdateExclusion resources.
+        :param pulumi.Input[_builtins.str] principal_arn: ARN of the IAM principal to exclude from having image pull times recorded.
+               
+               The following arguments are optional:
+        :param pulumi.Input[_builtins.str] region: Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+        """
+        if principal_arn is not None:
+            pulumi.set(__self__, "principal_arn", principal_arn)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+
+    @_builtins.property
+    @pulumi.getter(name="principalArn")
+    def principal_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        ARN of the IAM principal to exclude from having image pull times recorded.
+
+        The following arguments are optional:
+        """
+        return pulumi.get(self, "principal_arn")
+
+    @principal_arn.setter
+    def principal_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "principal_arn", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+        """
+        return pulumi.get(self, "region")
+
+    @region.setter
+    def region(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "region", value)
+
+
+@pulumi.type_token("aws:ecr/pullTimeUpdateExclusion:PullTimeUpdateExclusion")
+class PullTimeUpdateExclusion(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 principal_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 region: Optional[pulumi.Input[_builtins.str]] = None,
+                 __props__=None):
+        """
+        Manages an AWS ECR (Elastic Container Registry) Pull Time Update Exclusion.
+
+        ## Example Usage
+
+        ### Basic Usage
+
+        ```python
+        import pulumi
+        import json
+        import pulumi_aws as aws
+
+        example = aws.iam.Role("example",
+            name="example-role",
+            assume_role_policy=json.dumps({
+                "Version": "2012-10-17",
+                "Statement": [{
+                    "Action": "sts:AssumeRole",
+                    "Effect": "Allow",
+                    "Principal": {
+                        "Service": "ec2.amazonaws.com",
+                    },
+                }],
+            }))
+        example_role_policy = aws.iam.RolePolicy("example",
+            name="example-role-policy",
+            role=example.id,
+            policy=json.dumps({
+                "Version": "2012-10-17",
+                "Statement": [{
+                    "Effect": "Allow",
+                    "Action": [
+                        "ecr:GetAuthorizationToken",
+                        "ecr:BatchCheckLayerAvailability",
+                        "ecr:GetDownloadUrlForLayer",
+                        "ecr:BatchGetImage",
+                    ],
+                    "Resource": "*",
+                }],
+            }))
+        example_pull_time_update_exclusion = aws.ecr.PullTimeUpdateExclusion("example", principal_arn=example.arn)
+        ```
+
+        ### With IAM User
+
+        ```python
+        import pulumi
+        import json
+        import pulumi_aws as aws
+
+        example = aws.iam.User("example", name="example-user")
+        example_user_policy = aws.iam.UserPolicy("example",
+            name="example-user-policy",
+            user=example.name,
+            policy=json.dumps({
+                "Version": "2012-10-17",
+                "Statement": [{
+                    "Effect": "Allow",
+                    "Action": [
+                        "ecr:GetAuthorizationToken",
+                        "ecr:BatchCheckLayerAvailability",
+                        "ecr:GetDownloadUrlForLayer",
+                        "ecr:BatchGetImage",
+                    ],
+                    "Resource": "*",
+                }],
+            }))
+        example_pull_time_update_exclusion = aws.ecr.PullTimeUpdateExclusion("example", principal_arn=example.arn)
+        ```
+
+        ## Import
+
+        Using `pulumi import`, import ECR (Elastic Container Registry) Pull Time Update Exclusion using the `principal_arn`. For example:
+
+        ```sh
+        $ pulumi import aws:ecr/pullTimeUpdateExclusion:PullTimeUpdateExclusion example arn:aws:iam::123456789012:role/example-role
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[_builtins.str] principal_arn: ARN of the IAM principal to exclude from having image pull times recorded.
+               
+               The following arguments are optional:
+        :param pulumi.Input[_builtins.str] region: Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: PullTimeUpdateExclusionArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Manages an AWS ECR (Elastic Container Registry) Pull Time Update Exclusion.
+
+        ## Example Usage
+
+        ### Basic Usage
+
+        ```python
+        import pulumi
+        import json
+        import pulumi_aws as aws
+
+        example = aws.iam.Role("example",
+            name="example-role",
+            assume_role_policy=json.dumps({
+                "Version": "2012-10-17",
+                "Statement": [{
+                    "Action": "sts:AssumeRole",
+                    "Effect": "Allow",
+                    "Principal": {
+                        "Service": "ec2.amazonaws.com",
+                    },
+                }],
+            }))
+        example_role_policy = aws.iam.RolePolicy("example",
+            name="example-role-policy",
+            role=example.id,
+            policy=json.dumps({
+                "Version": "2012-10-17",
+                "Statement": [{
+                    "Effect": "Allow",
+                    "Action": [
+                        "ecr:GetAuthorizationToken",
+                        "ecr:BatchCheckLayerAvailability",
+                        "ecr:GetDownloadUrlForLayer",
+                        "ecr:BatchGetImage",
+                    ],
+                    "Resource": "*",
+                }],
+            }))
+        example_pull_time_update_exclusion = aws.ecr.PullTimeUpdateExclusion("example", principal_arn=example.arn)
+        ```
+
+        ### With IAM User
+
+        ```python
+        import pulumi
+        import json
+        import pulumi_aws as aws
+
+        example = aws.iam.User("example", name="example-user")
+        example_user_policy = aws.iam.UserPolicy("example",
+            name="example-user-policy",
+            user=example.name,
+            policy=json.dumps({
+                "Version": "2012-10-17",
+                "Statement": [{
+                    "Effect": "Allow",
+                    "Action": [
+                        "ecr:GetAuthorizationToken",
+                        "ecr:BatchCheckLayerAvailability",
+                        "ecr:GetDownloadUrlForLayer",
+                        "ecr:BatchGetImage",
+                    ],
+                    "Resource": "*",
+                }],
+            }))
+        example_pull_time_update_exclusion = aws.ecr.PullTimeUpdateExclusion("example", principal_arn=example.arn)
+        ```
+
+        ## Import
+
+        Using `pulumi import`, import ECR (Elastic Container Registry) Pull Time Update Exclusion using the `principal_arn`. For example:
+
+        ```sh
+        $ pulumi import aws:ecr/pullTimeUpdateExclusion:PullTimeUpdateExclusion example arn:aws:iam::123456789012:role/example-role
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param PullTimeUpdateExclusionArgs 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(PullTimeUpdateExclusionArgs, 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,
+                 principal_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 region: Optional[pulumi.Input[_builtins.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__ = PullTimeUpdateExclusionArgs.__new__(PullTimeUpdateExclusionArgs)
+
+            if principal_arn is None and not opts.urn:
+                raise TypeError("Missing required property 'principal_arn'")
+            __props__.__dict__["principal_arn"] = principal_arn
+            __props__.__dict__["region"] = region
+        super(PullTimeUpdateExclusion, __self__).__init__(
+            'aws:ecr/pullTimeUpdateExclusion:PullTimeUpdateExclusion',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            principal_arn: Optional[pulumi.Input[_builtins.str]] = None,
+            region: Optional[pulumi.Input[_builtins.str]] = None) -> 'PullTimeUpdateExclusion':
+        """
+        Get an existing PullTimeUpdateExclusion 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[_builtins.str] principal_arn: ARN of the IAM principal to exclude from having image pull times recorded.
+               
+               The following arguments are optional:
+        :param pulumi.Input[_builtins.str] region: Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _PullTimeUpdateExclusionState.__new__(_PullTimeUpdateExclusionState)
+
+        __props__.__dict__["principal_arn"] = principal_arn
+        __props__.__dict__["region"] = region
+        return PullTimeUpdateExclusion(resource_name, opts=opts, __props__=__props__)
+
+    @_builtins.property
+    @pulumi.getter(name="principalArn")
+    def principal_arn(self) -> pulumi.Output[_builtins.str]:
+        """
+        ARN of the IAM principal to exclude from having image pull times recorded.
+
+        The following arguments are optional:
+        """
+        return pulumi.get(self, "principal_arn")
+
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> pulumi.Output[_builtins.str]:
+        """
+        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+        """
+        return pulumi.get(self, "region")
+

pulumi_aws/ecr/repository_creation_template.py

@@ -34,7 +34,7 @@ class RepositoryCreationTemplateArgs:
                  resource_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
         """
         The set of arguments for constructing a RepositoryCreationTemplate resource.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         :param pulumi.Input[_builtins.str] prefix: The repository name prefix to match against. Use `ROOT` to match any prefix that doesn't explicitly match another template.
         :param pulumi.Input[_builtins.str] custom_role_arn: A custom IAM role to use for repository creation. Required if using repository tags or KMS encryption.
         :param pulumi.Input[_builtins.str] description: The description for this template.
@@ -70,7 +70,7 @@ class RepositoryCreationTemplateArgs:
     @pulumi.getter(name="appliedFors")
     def applied_fors(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
         """
-        Which features this template applies to. Must contain one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        Which features this template applies to. Must contain one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         """
         return pulumi.get(self, "applied_fors")
 
@@ -213,7 +213,7 @@ class _RepositoryCreationTemplateState:
                  resource_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
         """
         Input properties used for looking up and filtering RepositoryCreationTemplate resources.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         :param pulumi.Input[_builtins.str] custom_role_arn: A custom IAM role to use for repository creation. Required if using repository tags or KMS encryption.
         :param pulumi.Input[_builtins.str] description: The description for this template.
         :param pulumi.Input[Sequence[pulumi.Input['RepositoryCreationTemplateEncryptionConfigurationArgs']]] encryption_configurations: Encryption configuration for any created repositories. See below for schema.
@@ -254,7 +254,7 @@ class _RepositoryCreationTemplateState:
     @pulumi.getter(name="appliedFors")
     def applied_fors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        Which features this template applies to. Must contain one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        Which features this template applies to. Must contain one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         """
         return pulumi.get(self, "applied_fors")
 
@@ -486,7 +486,7 @@ class RepositoryCreationTemplate(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         :param pulumi.Input[_builtins.str] custom_role_arn: A custom IAM role to use for repository creation. Required if using repository tags or KMS encryption.
         :param pulumi.Input[_builtins.str] description: The description for this template.
         :param pulumi.Input[Sequence[pulumi.Input[Union['RepositoryCreationTemplateEncryptionConfigurationArgs', 'RepositoryCreationTemplateEncryptionConfigurationArgsDict']]]] encryption_configurations: Encryption configuration for any created repositories. See below for schema.
@@ -657,7 +657,7 @@ class RepositoryCreationTemplate(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[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] applied_fors: Which features this template applies to. Must contain one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         :param pulumi.Input[_builtins.str] custom_role_arn: A custom IAM role to use for repository creation. Required if using repository tags or KMS encryption.
         :param pulumi.Input[_builtins.str] description: The description for this template.
         :param pulumi.Input[Sequence[pulumi.Input[Union['RepositoryCreationTemplateEncryptionConfigurationArgs', 'RepositoryCreationTemplateEncryptionConfigurationArgsDict']]]] encryption_configurations: Encryption configuration for any created repositories. See below for schema.
@@ -691,7 +691,7 @@ class RepositoryCreationTemplate(pulumi.CustomResource):
     @pulumi.getter(name="appliedFors")
     def applied_fors(self) -> pulumi.Output[Sequence[_builtins.str]]:
         """
-        Which features this template applies to. Must contain one or more of `PULL_THROUGH_CACHE` or `REPLICATION`.
+        Which features this template applies to. Must contain one or more of `CREATE_ON_PUSH`, `PULL_THROUGH_CACHE`, or `REPLICATION`.
         """
         return pulumi.get(self, "applied_fors")
 

pulumi_aws/ecs/_inputs.py

@@ -536,6 +536,10 @@ if not MYPY:
         """
         The network configuration for Amazon ECS Managed Instances. This specifies the subnets and security groups that instances use for network connectivity. Detailed below.
         """
+        capacity_option_type: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The purchasing option for the EC2 instances used in the capacity provider. Determines whether to use On-Demand or Spot instances. Valid values are `ON_DEMAND` and `SPOT`. Defaults to `ON_DEMAND` when not specified. Changing this value will trigger replacement of the capacity provider. For more information, see [Amazon EC2 billing and purchasing options](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-purchasing-options.html) in the Amazon EC2 User Guide.
+        """
         instance_requirements: NotRequired[pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateInstanceRequirementsArgsDict']]
         """
         The instance requirements. You can specify the instance types and instance requirements such as vCPU count, memory, network performance, and accelerator specifications. Amazon ECS automatically selects the instances that match the specified criteria. Detailed below.
@@ -556,18 +560,22 @@ class CapacityProviderManagedInstancesProviderInstanceLaunchTemplateArgs:
     def __init__(__self__, *,
                  ec2_instance_profile_arn: pulumi.Input[_builtins.str],
                  network_configuration: pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateNetworkConfigurationArgs'],
+                 capacity_option_type: Optional[pulumi.Input[_builtins.str]] = None,
                  instance_requirements: Optional[pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateInstanceRequirementsArgs']] = None,
                  monitoring: Optional[pulumi.Input[_builtins.str]] = None,
                  storage_configuration: Optional[pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateStorageConfigurationArgs']] = None):
         """
         :param pulumi.Input[_builtins.str] ec2_instance_profile_arn: The Amazon Resource Name (ARN) of the instance profile that Amazon ECS applies to Amazon ECS Managed Instances. This instance profile must include the necessary permissions for your tasks to access AWS services and resources. For more information, see [Amazon ECS instance profile for Managed Instances](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html) in the Amazon ECS Developer Guide.
         :param pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateNetworkConfigurationArgs'] network_configuration: The network configuration for Amazon ECS Managed Instances. This specifies the subnets and security groups that instances use for network connectivity. Detailed below.
+        :param pulumi.Input[_builtins.str] capacity_option_type: The purchasing option for the EC2 instances used in the capacity provider. Determines whether to use On-Demand or Spot instances. Valid values are `ON_DEMAND` and `SPOT`. Defaults to `ON_DEMAND` when not specified. Changing this value will trigger replacement of the capacity provider. For more information, see [Amazon EC2 billing and purchasing options](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-purchasing-options.html) in the Amazon EC2 User Guide.
         :param pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateInstanceRequirementsArgs'] instance_requirements: The instance requirements. You can specify the instance types and instance requirements such as vCPU count, memory, network performance, and accelerator specifications. Amazon ECS automatically selects the instances that match the specified criteria. Detailed below.
         :param pulumi.Input[_builtins.str] monitoring: CloudWatch provides two categories of monitoring: basic monitoring and detailed monitoring. By default, your managed instance is configured for basic monitoring. You can optionally enable detailed monitoring to help you more quickly identify and act on operational issues. You can enable or turn off detailed monitoring at launch or when the managed instance is running or stopped. For more information, see [Detailed monitoring for Amazon ECS Managed Instances](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-metrics.html) in the Amazon ECS Developer Guide. Valid values are `BASIC` and `DETAILED`.
         :param pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateStorageConfigurationArgs'] storage_configuration: The storage configuration for Amazon ECS Managed Instances. This defines the root volume size and type for the instances. Detailed below.
         """
         pulumi.set(__self__, "ec2_instance_profile_arn", ec2_instance_profile_arn)
         pulumi.set(__self__, "network_configuration", network_configuration)
+        if capacity_option_type is not None:
+            pulumi.set(__self__, "capacity_option_type", capacity_option_type)
         if instance_requirements is not None:
             pulumi.set(__self__, "instance_requirements", instance_requirements)
         if monitoring is not None:
@@ -599,6 +607,18 @@ class CapacityProviderManagedInstancesProviderInstanceLaunchTemplateArgs:
     def network_configuration(self, value: pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateNetworkConfigurationArgs']):
         pulumi.set(self, "network_configuration", value)
 
+    @_builtins.property
+    @pulumi.getter(name="capacityOptionType")
+    def capacity_option_type(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The purchasing option for the EC2 instances used in the capacity provider. Determines whether to use On-Demand or Spot instances. Valid values are `ON_DEMAND` and `SPOT`. Defaults to `ON_DEMAND` when not specified. Changing this value will trigger replacement of the capacity provider. For more information, see [Amazon EC2 billing and purchasing options](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-purchasing-options.html) in the Amazon EC2 User Guide.
+        """
+        return pulumi.get(self, "capacity_option_type")
+
+    @capacity_option_type.setter
+    def capacity_option_type(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "capacity_option_type", value)
+
     @_builtins.property
     @pulumi.getter(name="instanceRequirements")
     def instance_requirements(self) -> Optional[pulumi.Input['CapacityProviderManagedInstancesProviderInstanceLaunchTemplateInstanceRequirementsArgs']]: