r'''
# EC2 Image Builder Construct Library

<!--BEGIN STABILITY BANNER-->---


![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg?style=for-the-badge)

> The APIs of higher level constructs in this module are experimental and under active development.
> They are subject to non-backward compatible changes or removal in any future version. These are
> not subject to the [Semantic Versioning](https://semver.org/) model and breaking changes will be
> announced in the release notes. This means that while you may use them, you may need to update
> your source code when upgrading to a newer version of this package.

---
<!--END STABILITY BANNER-->

This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.

## README

[Amazon EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) is a
fully managed AWS service that helps you automate the creation, management, and deployment of customized, secure, and
up-to-date server images. You can use Image Builder to create Amazon Machine Images (AMIs) and container images for use
across AWS Regions.

This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project. It allows you to define
Image Builder pipelines, images, recipes, components, workflows, and lifecycle policies.
A component defines the sequence of steps required to customize an instance during image creation (build component) or
test an instance launched from the created image (test component). Components are created from declarative YAML or JSON
documents that describe runtime configuration for building, validating, or testing instances. Components are included
when added to the image recipe or container recipe for an image build.

EC2 Image Builder supports AWS-managed components for common tasks, AWS Marketplace components, and custom components
that you create. Components run during specific workflow phases: build and validate phases during the build stage, and
test phase during the test stage.

### Component

A component defines the sequence of steps required to customize an instance during image creation (build component) or
test an instance launched from the created image (test component). Components are created from declarative YAML or JSON
documents that describe runtime configuration for building, validating, or testing instances. Components are included
when added to the image recipe or container recipe for an image build.

EC2 Image Builder supports AWS-managed components for common tasks, AWS Marketplace components, and custom components
that you create. Components run during specific workflow phases: build and validate phases during the build stage, and
test phase during the test stage.

#### Basic Usage

Create a component with the required properties: platform and component data.

```python
component = imagebuilder.Component(self, "MyComponent",
    platform=imagebuilder.Platform.LINUX,
    data=imagebuilder.ComponentData.from_json_object({
        "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
        "phases": [{
            "name": imagebuilder.ComponentPhaseName.BUILD,
            "steps": [{
                "name": "install-app",
                "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                "inputs": {
                    "commands": ["echo \"Installing my application...\"", "yum update -y"]
                }
            }
            ]
        }
        ]
    })
)
```

#### Component Data Sources

##### Inline Component Data

Use `ComponentData.fromInline()` for existing YAML/JSON definitions:

```python
component = imagebuilder.Component(self, "InlineComponent",
    platform=imagebuilder.Platform.LINUX,
    data=imagebuilder.ComponentData.from_inline("""
        name: my-component
        schemaVersion: 1.0
        phases:
          - name: build
            steps:
              - name: update-os
                action: ExecuteBash
                inputs:
                  commands: ['yum update -y']
        """)
)
```

##### JSON Object Component Data

Most developer-friendly approach using objects:

```python
component = imagebuilder.Component(self, "JsonComponent",
    platform=imagebuilder.Platform.LINUX,
    data=imagebuilder.ComponentData.from_json_object({
        "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
        "phases": [{
            "name": imagebuilder.ComponentPhaseName.BUILD,
            "steps": [{
                "name": "configure-app",
                "action": imagebuilder.ComponentAction.CREATE_FILE,
                "inputs": {
                    "path": "/etc/myapp/config.json",
                    "content": "{\"env\": \"production\"}"
                }
            }
            ]
        }
        ]
    })
)
```

##### Structured Component Document

For type-safe, CDK-native definitions with enhanced properties like `timeout` and `onFailure`.

###### Defining a component step

You can define steps in the component which will be executed in order when the component is applied:

```python
step = imagebuilder.ComponentDocumentStep(
    name="configure-app",
    action=imagebuilder.ComponentAction.CREATE_FILE,
    inputs=imagebuilder.ComponentStepInputs.from_object({
        "path": "/etc/myapp/config.json",
        "content": "{\"env\": \"production\"}"
    })
)
```

###### Defining a component phase

Phases group steps together, which run in sequence when building, validating or testing in the component:

```python
phase = imagebuilder.ComponentDocumentPhase(
    name=imagebuilder.ComponentPhaseName.BUILD,
    steps=[imagebuilder.ComponentDocumentStep(
        name="configure-app",
        action=imagebuilder.ComponentAction.CREATE_FILE,
        inputs=imagebuilder.ComponentStepInputs.from_object({
            "path": "/etc/myapp/config.json",
            "content": "{\"env\": \"production\"}"
        })
    )
    ]
)
```

###### Defining a component

The component data defines all steps across the provided phases to execute during the build:

```python
component = imagebuilder.Component(self, "StructuredComponent",
    platform=imagebuilder.Platform.LINUX,
    data=imagebuilder.ComponentData.from_component_document_json_object(
        schema_version=imagebuilder.ComponentSchemaVersion.V1_0,
        phases=[imagebuilder.ComponentDocumentPhase(
            name=imagebuilder.ComponentPhaseName.BUILD,
            steps=[imagebuilder.ComponentDocumentStep(
                name="install-with-timeout",
                action=imagebuilder.ComponentAction.EXECUTE_BASH,
                timeout=Duration.minutes(10),
                on_failure=imagebuilder.ComponentOnFailure.CONTINUE,
                inputs=imagebuilder.ComponentStepInputs.from_object({
                    "commands": ["./install-script.sh"]
                })
            )
            ]
        )
        ]
    )
)
```

##### S3 Component Data

For those components you want to upload or have uploaded to S3:

```python
# Upload a local file
component_from_asset = imagebuilder.Component(self, "AssetComponent",
    platform=imagebuilder.Platform.LINUX,
    data=imagebuilder.ComponentData.from_asset(self, "ComponentAsset", "./my-component.yml")
)

# Reference an existing S3 object
bucket = s3.Bucket.from_bucket_name(self, "ComponentBucket", "my-components-bucket")
component_from_s3 = imagebuilder.Component(self, "S3Component",
    platform=imagebuilder.Platform.LINUX,
    data=imagebuilder.ComponentData.from_s3(bucket, "components/my-component.yml")
)
```

#### Encrypt component data with a KMS key

You can encrypt component data with a KMS key, so that only principals with access to decrypt with the key are able to
access the component data.

```python
component = imagebuilder.Component(self, "EncryptedComponent",
    platform=imagebuilder.Platform.LINUX,
    kms_key=kms.Key(self, "ComponentKey"),
    data=imagebuilder.ComponentData.from_json_object({
        "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
        "phases": [{
            "name": imagebuilder.ComponentPhaseName.BUILD,
            "steps": [{
                "name": "secure-setup",
                "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                "inputs": {
                    "commands": ["echo \"This component data is encrypted with KMS\""]
                }
            }
            ]
        }
        ]
    })
)
```

#### AWS-Managed Components

AWS provides a collection of managed components for common tasks:

```python
# Install AWS CLI v2
aws_cli_component = imagebuilder.AwsManagedComponent.aws_cli_v2(self, "AwsCli",
    platform=imagebuilder.Platform.LINUX
)

# Update the operating system
update_component = imagebuilder.AwsManagedComponent.update_oS(self, "UpdateOS",
    platform=imagebuilder.Platform.LINUX
)

# Reference any AWS-managed component by name
custom_aws_component = imagebuilder.AwsManagedComponent.from_aws_managed_component_name(self, "CloudWatchAgent", "amazon-cloudwatch-agent-linux")
```

#### AWS Marketplace Components

You can reference AWS Marketplace components using the marketplace component name and its product ID:

```python
marketplace_component = imagebuilder.AwsMarketplaceComponent.from_aws_marketplace_component_attributes(self, "MarketplaceComponent",
    component_name="my-marketplace-component",
    marketplace_product_id="prod-1234567890abcdef0"
)
```

### Infrastructure Configuration

Infrastructure configuration defines the compute resources and environment settings used during the image building
process. This includes instance types, IAM instance profile, VPC settings, subnets, security groups, SNS topics for
notifications, logging configuration, and troubleshooting settings like whether to terminate instances on failure or
keep them running for debugging. These settings are applied to builds when included in an image or an image pipeline.

```python
infrastructure_configuration = imagebuilder.InfrastructureConfiguration(self, "InfrastructureConfiguration",
    infrastructure_configuration_name="test-infrastructure-configuration",
    description="An Infrastructure Configuration",
    # Optional - instance types to use for build/test
    instance_types=[
        ec2.InstanceType.of(ec2.InstanceClass.STANDARD7_INTEL, ec2.InstanceSize.LARGE),
        ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.LARGE)
    ],
    # Optional - create an instance profile with necessary permissions
    instance_profile=iam.InstanceProfile(self, "InstanceProfile",
        instance_profile_name="test-instance-profile",
        role=iam.Role(self, "InstanceProfileRole",
            assumed_by=iam.ServicePrincipal.from_static_service_principle_name("ec2.amazonaws.com"),
            managed_policies=[
                iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSSMManagedInstanceCore"),
                iam.ManagedPolicy.from_aws_managed_policy_name("EC2InstanceProfileForImageBuilder")
            ]
        )
    ),
    # Use VPC network configuration
    vpc=vpc,
    subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
    security_groups=[ec2.SecurityGroup.from_security_group_id(self, "SecurityGroup", vpc.vpc_default_security_group)],
    key_pair=ec2.KeyPair.from_key_pair_name(self, "KeyPair", "imagebuilder-instance-key-pair"),
    terminate_instance_on_failure=True,
    # Optional - IMDSv2 settings
    http_tokens=imagebuilder.HttpTokens.REQUIRED,
    http_put_response_hop_limit=1,
    # Optional - publish image completion messages to an SNS topic
    notification_topic=sns.Topic.from_topic_arn(self, "Topic",
        self.format_arn(service="sns", resource="image-builder-topic")),
    # Optional - log settings. Logging is enabled by default
    logging=imagebuilder.InfrastructureConfigurationLogging(
        s3_bucket=s3.Bucket.from_bucket_name(self, "LogBucket", f"imagebuilder-logging-{Aws.ACCOUNT_ID}"),
        s3_key_prefix="imagebuilder-logs"
    ),
    # Optional - host placement settings
    ec2_instance_availability_zone=Stack.of(self).availability_zones[0],
    ec2_instance_host_id=dedicated_host.attr_host_id,
    ec2_instance_tenancy=imagebuilder.Tenancy.HOST,
    resource_tags={
        "Environment": "production"
    }
)
```

### Distribution Configuration

Distribution configuration defines how and where your built images are distributed after successful creation. For AMIs,
this includes target AWS Regions, KMS encryption keys, account sharing permissions, License Manager associations, and
launch template configurations. For container images, it specifies the target Amazon ECR repositories across regions.
A distribution configuration can be associated with an image or an image pipeline to define these distribution settings
for image builds.

#### AMI Distributions

AMI distributions can be defined to copy and modify AMIs in different accounts and regions, and apply them to launch
templates, SSM parameters, etc.:

```python
distribution_configuration = imagebuilder.DistributionConfiguration(self, "DistributionConfiguration",
    distribution_configuration_name="test-distribution-configuration",
    description="A Distribution Configuration",
    ami_distributions=[imagebuilder.AmiDistribution(
        # Distribute AMI to us-east-2 and publish the AMI ID to an SSM parameter
        region="us-east-2",
        ssm_parameters=[imagebuilder.SSMParameterConfigurations(
            parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossRegionParameter",
                parameter_name="/imagebuilder/ami",
                force_dynamic_reference=True
            )
        )
        ]
    )
    ]
)

# For AMI-based image builds - add an AMI distribution in the current region
distribution_configuration.add_ami_distributions(
    ami_name="imagebuilder-{{ imagebuilder:buildDate }}",
    ami_description="Build AMI",
    ami_kms_key=kms.Key.from_lookup(self, "ComponentKey", alias_name="alias/distribution-encryption-key"),
    # Copy the AMI to different accounts
    ami_target_account_ids=["123456789012", "098765432109"],
    # Add launch permissions on the AMI
    ami_launch_permission=imagebuilder.AmiLaunchPermission(
        organization_arns=[
            self.format_arn(region="", service="organizations", resource="organization", resource_name="o-1234567abc")
        ],
        organizational_unit_arns=[
            self.format_arn(
                region="",
                service="organizations",
                resource="ou",
                resource_name="o-1234567abc/ou-a123-b4567890"
            )
        ],
        is_public_user_group=True,
        account_ids=["234567890123"]
    ),
    # Attach tags to the AMI
    ami_tags={
        "Environment": "production",
        "Version": "{{ imagebuilder:buildVersion }}"
    },
    # Optional - publish the distributed AMI ID to an SSM parameter
    ssm_parameters=[imagebuilder.SSMParameterConfigurations(
        parameter=ssm.StringParameter.from_string_parameter_attributes(self, "Parameter",
            parameter_name="/imagebuilder/ami",
            force_dynamic_reference=True
        )
    ), imagebuilder.SSMParameterConfigurations(
        ami_account="098765432109",
        data_type=ssm.ParameterDataType.TEXT,
        parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossAccountParameter",
            parameter_name="imagebuilder-prod-ami",
            force_dynamic_reference=True
        )
    )
    ],
    # Optional - create a new launch template version with the distributed AMI ID
    launch_templates=[imagebuilder.LaunchTemplateConfiguration(
        launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "LaunchTemplate",
            launch_template_id="lt-1234"
        ),
        set_default_version=True
    ), imagebuilder.LaunchTemplateConfiguration(
        account_id="123456789012",
        launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "CrossAccountLaunchTemplate",
            launch_template_id="lt-5678"
        ),
        set_default_version=True
    )
    ],
    # Optional - enable Fast Launch on an imported launch template
    fast_launch_configurations=[imagebuilder.FastLaunchConfiguration(
        enabled=True,
        launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "FastLaunchLT",
            launch_template_name="fast-launch-lt"
        ),
        max_parallel_launches=10,
        target_snapshot_count=2
    )
    ],
    # Optional - license configurations to apply to the AMI
    license_configuration_arns=["arn:aws:license-manager:us-west-2:123456789012:license-configuration:lic-abcdefghijklmnopqrstuvwxyz"
    ]
)
```

#### Container Distributions

##### Container repositories

Container distributions can be configured to distribute to ECR repositories:

```python
ecr_repository = ecr.Repository.from_repository_name(self, "ECRRepository", "my-repo")
image_builder_repository = imagebuilder.Repository.from_ecr(ecr_repository)
```

##### Defining a container distribution

You can configure the container repositories as well as the description and tags applied to the distributed container
images:

```python
ecr_repository = ecr.Repository.from_repository_name(self, "ECRRepository", "my-repo")
container_repository = imagebuilder.Repository.from_ecr(ecr_repository)
container_distribution_configuration = imagebuilder.DistributionConfiguration(self, "ContainerDistributionConfiguration")

container_distribution_configuration.add_container_distributions(
    container_repository=container_repository,
    container_description="Test container image",
    container_tags=["latest", "latest-1.0"]
)
```
'''
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)

import abc
import builtins
import datetime
import enum
import typing

import jsii
import publication
import typing_extensions

import typeguard
from importlib.metadata import version as _metadata_package_version
TYPEGUARD_MAJOR_VERSION = int(_metadata_package_version('typeguard').split('.')[0])

def check_type(argname: str, value: object, expected_type: typing.Any) -> typing.Any:
    if TYPEGUARD_MAJOR_VERSION <= 2:
        return typeguard.check_type(argname=argname, value=value, expected_type=expected_type) # type:ignore
    else:
        if isinstance(value, jsii._reference_map.InterfaceDynamicProxy): # pyright: ignore [reportAttributeAccessIssue]
           pass
        else:
            if TYPEGUARD_MAJOR_VERSION == 3:
                typeguard.config.collection_check_strategy = typeguard.CollectionCheckStrategy.ALL_ITEMS # type:ignore
                typeguard.check_type(value=value, expected_type=expected_type) # type:ignore
            else:
                typeguard.check_type(value=value, expected_type=expected_type, collection_check_strategy=typeguard.CollectionCheckStrategy.ALL_ITEMS) # type:ignore

from ._jsii import *

import aws_cdk as _aws_cdk_ceddda9d
import aws_cdk.aws_ec2 as _aws_cdk_aws_ec2_ceddda9d
import aws_cdk.aws_ecr as _aws_cdk_aws_ecr_ceddda9d
import aws_cdk.aws_iam as _aws_cdk_aws_iam_ceddda9d
import aws_cdk.aws_kms as _aws_cdk_aws_kms_ceddda9d
import aws_cdk.aws_s3 as _aws_cdk_aws_s3_ceddda9d
import aws_cdk.aws_s3_assets as _aws_cdk_aws_s3_assets_ceddda9d
import aws_cdk.aws_sns as _aws_cdk_aws_sns_ceddda9d
import aws_cdk.aws_ssm as _aws_cdk_aws_ssm_ceddda9d
import aws_cdk.interfaces.aws_kms as _aws_cdk_interfaces_aws_kms_ceddda9d
import constructs as _constructs_77d1e7e8


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.AmiDistribution",
    jsii_struct_bases=[],
    name_mapping={
        "ami_description": "amiDescription",
        "ami_kms_key": "amiKmsKey",
        "ami_launch_permission": "amiLaunchPermission",
        "ami_name": "amiName",
        "ami_tags": "amiTags",
        "ami_target_account_ids": "amiTargetAccountIds",
        "fast_launch_configurations": "fastLaunchConfigurations",
        "launch_templates": "launchTemplates",
        "license_configuration_arns": "licenseConfigurationArns",
        "region": "region",
        "ssm_parameters": "ssmParameters",
    },
)
class AmiDistribution:
    def __init__(
        self,
        *,
        ami_description: typing.Optional[builtins.str] = None,
        ami_kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
        ami_launch_permission: typing.Optional[typing.Union["AmiLaunchPermission", typing.Dict[builtins.str, typing.Any]]] = None,
        ami_name: typing.Optional[builtins.str] = None,
        ami_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        ami_target_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        fast_launch_configurations: typing.Optional[typing.Sequence[typing.Union["FastLaunchConfiguration", typing.Dict[builtins.str, typing.Any]]]] = None,
        launch_templates: typing.Optional[typing.Sequence[typing.Union["LaunchTemplateConfiguration", typing.Dict[builtins.str, typing.Any]]]] = None,
        license_configuration_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        region: typing.Optional[builtins.str] = None,
        ssm_parameters: typing.Optional[typing.Sequence[typing.Union["SSMParameterConfigurations", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''(experimental) The regional distribution settings to use for an AMI build.

        :param ami_description: (experimental) The description of the AMI. Default: None
        :param ami_kms_key: (experimental) The KMS key to encrypt the distributed AMI with. Default: None
        :param ami_launch_permission: (experimental) The launch permissions for the AMI, defining which principals are allowed to access the AMI. Default: None
        :param ami_name: (experimental) The name to use for the distributed AMIs. Default: A name is generated from the image recipe name
        :param ami_tags: (experimental) The tags to apply to the distributed AMIs. Default: None
        :param ami_target_account_ids: (experimental) The account IDs to copy the output AMI to. Default: None
        :param fast_launch_configurations: (experimental) The fast launch configurations to use for enabling EC2 Fast Launch on the distributed Windows AMI. Default: None
        :param launch_templates: (experimental) The launch templates to apply the distributed AMI to. Default: None
        :param license_configuration_arns: (experimental) The License Manager license configuration ARNs to apply to the distributed AMIs. Default: None
        :param region: (experimental) The target region to distribute AMIs to. Default: The current region is used
        :param ssm_parameters: (experimental) The SSM parameters to create or update for the distributed AMIs. Default: None

        :stability: experimental
        :exampleMetadata: infused

        Example::

            distribution_configuration = imagebuilder.DistributionConfiguration(self, "DistributionConfiguration",
                distribution_configuration_name="test-distribution-configuration",
                description="A Distribution Configuration",
                ami_distributions=[imagebuilder.AmiDistribution(
                    # Distribute AMI to us-east-2 and publish the AMI ID to an SSM parameter
                    region="us-east-2",
                    ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                        parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossRegionParameter",
                            parameter_name="/imagebuilder/ami",
                            force_dynamic_reference=True
                        )
                    )
                    ]
                )
                ]
            )
            
            # For AMI-based image builds - add an AMI distribution in the current region
            distribution_configuration.add_ami_distributions(
                ami_name="imagebuilder-{{ imagebuilder:buildDate }}",
                ami_description="Build AMI",
                ami_kms_key=kms.Key.from_lookup(self, "ComponentKey", alias_name="alias/distribution-encryption-key"),
                # Copy the AMI to different accounts
                ami_target_account_ids=["123456789012", "098765432109"],
                # Add launch permissions on the AMI
                ami_launch_permission=imagebuilder.AmiLaunchPermission(
                    organization_arns=[
                        self.format_arn(region="", service="organizations", resource="organization", resource_name="o-1234567abc")
                    ],
                    organizational_unit_arns=[
                        self.format_arn(
                            region="",
                            service="organizations",
                            resource="ou",
                            resource_name="o-1234567abc/ou-a123-b4567890"
                        )
                    ],
                    is_public_user_group=True,
                    account_ids=["234567890123"]
                ),
                # Attach tags to the AMI
                ami_tags={
                    "Environment": "production",
                    "Version": "{{ imagebuilder:buildVersion }}"
                },
                # Optional - publish the distributed AMI ID to an SSM parameter
                ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                    parameter=ssm.StringParameter.from_string_parameter_attributes(self, "Parameter",
                        parameter_name="/imagebuilder/ami",
                        force_dynamic_reference=True
                    )
                ), imagebuilder.SSMParameterConfigurations(
                    ami_account="098765432109",
                    data_type=ssm.ParameterDataType.TEXT,
                    parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossAccountParameter",
                        parameter_name="imagebuilder-prod-ami",
                        force_dynamic_reference=True
                    )
                )
                ],
                # Optional - create a new launch template version with the distributed AMI ID
                launch_templates=[imagebuilder.LaunchTemplateConfiguration(
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "LaunchTemplate",
                        launch_template_id="lt-1234"
                    ),
                    set_default_version=True
                ), imagebuilder.LaunchTemplateConfiguration(
                    account_id="123456789012",
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "CrossAccountLaunchTemplate",
                        launch_template_id="lt-5678"
                    ),
                    set_default_version=True
                )
                ],
                # Optional - enable Fast Launch on an imported launch template
                fast_launch_configurations=[imagebuilder.FastLaunchConfiguration(
                    enabled=True,
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "FastLaunchLT",
                        launch_template_name="fast-launch-lt"
                    ),
                    max_parallel_launches=10,
                    target_snapshot_count=2
                )
                ],
                # Optional - license configurations to apply to the AMI
                license_configuration_arns=["arn:aws:license-manager:us-west-2:123456789012:license-configuration:lic-abcdefghijklmnopqrstuvwxyz"
                ]
            )
        '''
        if isinstance(ami_launch_permission, dict):
            ami_launch_permission = AmiLaunchPermission(**ami_launch_permission)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6bbb50c8ed5cb401fdf362f5d0a7b629c2c082dbdaadf32bcf6aef95e968f20b)
            check_type(argname="argument ami_description", value=ami_description, expected_type=type_hints["ami_description"])
            check_type(argname="argument ami_kms_key", value=ami_kms_key, expected_type=type_hints["ami_kms_key"])
            check_type(argname="argument ami_launch_permission", value=ami_launch_permission, expected_type=type_hints["ami_launch_permission"])
            check_type(argname="argument ami_name", value=ami_name, expected_type=type_hints["ami_name"])
            check_type(argname="argument ami_tags", value=ami_tags, expected_type=type_hints["ami_tags"])
            check_type(argname="argument ami_target_account_ids", value=ami_target_account_ids, expected_type=type_hints["ami_target_account_ids"])
            check_type(argname="argument fast_launch_configurations", value=fast_launch_configurations, expected_type=type_hints["fast_launch_configurations"])
            check_type(argname="argument launch_templates", value=launch_templates, expected_type=type_hints["launch_templates"])
            check_type(argname="argument license_configuration_arns", value=license_configuration_arns, expected_type=type_hints["license_configuration_arns"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument ssm_parameters", value=ssm_parameters, expected_type=type_hints["ssm_parameters"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if ami_description is not None:
            self._values["ami_description"] = ami_description
        if ami_kms_key is not None:
            self._values["ami_kms_key"] = ami_kms_key
        if ami_launch_permission is not None:
            self._values["ami_launch_permission"] = ami_launch_permission
        if ami_name is not None:
            self._values["ami_name"] = ami_name
        if ami_tags is not None:
            self._values["ami_tags"] = ami_tags
        if ami_target_account_ids is not None:
            self._values["ami_target_account_ids"] = ami_target_account_ids
        if fast_launch_configurations is not None:
            self._values["fast_launch_configurations"] = fast_launch_configurations
        if launch_templates is not None:
            self._values["launch_templates"] = launch_templates
        if license_configuration_arns is not None:
            self._values["license_configuration_arns"] = license_configuration_arns
        if region is not None:
            self._values["region"] = region
        if ssm_parameters is not None:
            self._values["ssm_parameters"] = ssm_parameters

    @builtins.property
    def ami_description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The description of the AMI.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ami_description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ami_kms_key(self) -> typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey]:
        '''(experimental) The KMS key to encrypt the distributed AMI with.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ami_kms_key")
        return typing.cast(typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey], result)

    @builtins.property
    def ami_launch_permission(self) -> typing.Optional["AmiLaunchPermission"]:
        '''(experimental) The launch permissions for the AMI, defining which principals are allowed to access the AMI.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ami_launch_permission")
        return typing.cast(typing.Optional["AmiLaunchPermission"], result)

    @builtins.property
    def ami_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name to use for the distributed AMIs.

        :default: A name is generated from the image recipe name

        :stability: experimental
        '''
        result = self._values.get("ami_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ami_tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(experimental) The tags to apply to the distributed AMIs.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ami_tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def ami_target_account_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) The account IDs to copy the output AMI to.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ami_target_account_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def fast_launch_configurations(
        self,
    ) -> typing.Optional[typing.List["FastLaunchConfiguration"]]:
        '''(experimental) The fast launch configurations to use for enabling EC2 Fast Launch on the distributed Windows AMI.

        :default: None

        :see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableFastLaunch.html
        :stability: experimental
        '''
        result = self._values.get("fast_launch_configurations")
        return typing.cast(typing.Optional[typing.List["FastLaunchConfiguration"]], result)

    @builtins.property
    def launch_templates(
        self,
    ) -> typing.Optional[typing.List["LaunchTemplateConfiguration"]]:
        '''(experimental) The launch templates to apply the distributed AMI to.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("launch_templates")
        return typing.cast(typing.Optional[typing.List["LaunchTemplateConfiguration"]], result)

    @builtins.property
    def license_configuration_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) The License Manager license configuration ARNs to apply to the distributed AMIs.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("license_configuration_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) The target region to distribute AMIs to.

        :default: The current region is used

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ssm_parameters(
        self,
    ) -> typing.Optional[typing.List["SSMParameterConfigurations"]]:
        '''(experimental) The SSM parameters to create or update for the distributed AMIs.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ssm_parameters")
        return typing.cast(typing.Optional[typing.List["SSMParameterConfigurations"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmiDistribution(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.AmiLaunchPermission",
    jsii_struct_bases=[],
    name_mapping={
        "account_ids": "accountIds",
        "is_public_user_group": "isPublicUserGroup",
        "organizational_unit_arns": "organizationalUnitArns",
        "organization_arns": "organizationArns",
    },
)
class AmiLaunchPermission:
    def __init__(
        self,
        *,
        account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        is_public_user_group: typing.Optional[builtins.bool] = None,
        organizational_unit_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        organization_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''(experimental) The launch permissions for the AMI, defining which principals are allowed to access the AMI.

        :param account_ids: (experimental) The AWS account IDs to share the AMI with. Default: None
        :param is_public_user_group: (experimental) Whether to make the AMI public. Block public access for AMIs must be disabled to make the AMI public. WARNING: Making an AMI public exposes it to any AWS account globally. Ensure the AMI does not contain: - Sensitive data or credentials - Proprietary software or configurations - Internal network information or security settings For more information on blocking public access for AMIs, see: `Understand block public access for AMIs <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html>`_ Default: false
        :param organizational_unit_arns: (experimental) The ARNs for the AWS Organizations organizational units to share the AMI with. Default: None
        :param organization_arns: (experimental) The ARNs for the AWS Organization that you want to share the AMI with. Default: None

        :stability: experimental
        :exampleMetadata: infused

        Example::

            distribution_configuration = imagebuilder.DistributionConfiguration(self, "DistributionConfiguration",
                distribution_configuration_name="test-distribution-configuration",
                description="A Distribution Configuration",
                ami_distributions=[imagebuilder.AmiDistribution(
                    # Distribute AMI to us-east-2 and publish the AMI ID to an SSM parameter
                    region="us-east-2",
                    ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                        parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossRegionParameter",
                            parameter_name="/imagebuilder/ami",
                            force_dynamic_reference=True
                        )
                    )
                    ]
                )
                ]
            )
            
            # For AMI-based image builds - add an AMI distribution in the current region
            distribution_configuration.add_ami_distributions(
                ami_name="imagebuilder-{{ imagebuilder:buildDate }}",
                ami_description="Build AMI",
                ami_kms_key=kms.Key.from_lookup(self, "ComponentKey", alias_name="alias/distribution-encryption-key"),
                # Copy the AMI to different accounts
                ami_target_account_ids=["123456789012", "098765432109"],
                # Add launch permissions on the AMI
                ami_launch_permission=imagebuilder.AmiLaunchPermission(
                    organization_arns=[
                        self.format_arn(region="", service="organizations", resource="organization", resource_name="o-1234567abc")
                    ],
                    organizational_unit_arns=[
                        self.format_arn(
                            region="",
                            service="organizations",
                            resource="ou",
                            resource_name="o-1234567abc/ou-a123-b4567890"
                        )
                    ],
                    is_public_user_group=True,
                    account_ids=["234567890123"]
                ),
                # Attach tags to the AMI
                ami_tags={
                    "Environment": "production",
                    "Version": "{{ imagebuilder:buildVersion }}"
                },
                # Optional - publish the distributed AMI ID to an SSM parameter
                ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                    parameter=ssm.StringParameter.from_string_parameter_attributes(self, "Parameter",
                        parameter_name="/imagebuilder/ami",
                        force_dynamic_reference=True
                    )
                ), imagebuilder.SSMParameterConfigurations(
                    ami_account="098765432109",
                    data_type=ssm.ParameterDataType.TEXT,
                    parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossAccountParameter",
                        parameter_name="imagebuilder-prod-ami",
                        force_dynamic_reference=True
                    )
                )
                ],
                # Optional - create a new launch template version with the distributed AMI ID
                launch_templates=[imagebuilder.LaunchTemplateConfiguration(
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "LaunchTemplate",
                        launch_template_id="lt-1234"
                    ),
                    set_default_version=True
                ), imagebuilder.LaunchTemplateConfiguration(
                    account_id="123456789012",
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "CrossAccountLaunchTemplate",
                        launch_template_id="lt-5678"
                    ),
                    set_default_version=True
                )
                ],
                # Optional - enable Fast Launch on an imported launch template
                fast_launch_configurations=[imagebuilder.FastLaunchConfiguration(
                    enabled=True,
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "FastLaunchLT",
                        launch_template_name="fast-launch-lt"
                    ),
                    max_parallel_launches=10,
                    target_snapshot_count=2
                )
                ],
                # Optional - license configurations to apply to the AMI
                license_configuration_arns=["arn:aws:license-manager:us-west-2:123456789012:license-configuration:lic-abcdefghijklmnopqrstuvwxyz"
                ]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c99475ef38f88d24e515c5d4cfe68b2b801bf8855b6659a379ba52bbf9fc1a2e)
            check_type(argname="argument account_ids", value=account_ids, expected_type=type_hints["account_ids"])
            check_type(argname="argument is_public_user_group", value=is_public_user_group, expected_type=type_hints["is_public_user_group"])
            check_type(argname="argument organizational_unit_arns", value=organizational_unit_arns, expected_type=type_hints["organizational_unit_arns"])
            check_type(argname="argument organization_arns", value=organization_arns, expected_type=type_hints["organization_arns"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account_ids is not None:
            self._values["account_ids"] = account_ids
        if is_public_user_group is not None:
            self._values["is_public_user_group"] = is_public_user_group
        if organizational_unit_arns is not None:
            self._values["organizational_unit_arns"] = organizational_unit_arns
        if organization_arns is not None:
            self._values["organization_arns"] = organization_arns

    @builtins.property
    def account_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) The AWS account IDs to share the AMI with.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("account_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def is_public_user_group(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to make the AMI public. Block public access for AMIs must be disabled to make the AMI public.

        WARNING: Making an AMI public exposes it to any AWS account globally.
        Ensure the AMI does not contain:

        - Sensitive data or credentials
        - Proprietary software or configurations
        - Internal network information or security settings

        For more information on blocking public access for AMIs, see: `Understand block public access for AMIs <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html>`_

        :default: false

        :stability: experimental
        '''
        result = self._values.get("is_public_user_group")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def organizational_unit_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) The ARNs for the AWS Organizations organizational units to share the AMI with.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("organizational_unit_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def organization_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) The ARNs for the AWS Organization that you want to share the AMI with.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("organization_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmiLaunchPermission(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AwsManagedComponent(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.AwsManagedComponent",
):
    '''(experimental) Helper class for working with AWS-managed components.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        # Install AWS CLI v2
        aws_cli_component = imagebuilder.AwsManagedComponent.aws_cli_v2(self, "AwsCli",
            platform=imagebuilder.Platform.LINUX
        )
        
        # Update the operating system
        update_component = imagebuilder.AwsManagedComponent.update_oS(self, "UpdateOS",
            platform=imagebuilder.Platform.LINUX
        )
        
        # Reference any AWS-managed component by name
        custom_aws_component = imagebuilder.AwsManagedComponent.from_aws_managed_component_name(self, "CloudWatchAgent", "amazon-cloudwatch-agent-linux")
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="awsCliV2")
    @builtins.classmethod
    def aws_cli_v2(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> "IComponent":
        '''(experimental) Imports the AWS CLI v2 AWS-managed component.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28a85b2f57e866c107d58316256ca41b5310ce1316357a3af47fb8c9be257978)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsManagedComponentAttributes(
            component_name=component_name,
            component_version=component_version,
            platform=platform,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "awsCliV2", [scope, id, attrs]))

    @jsii.member(jsii_name="fromAwsManagedComponentAttributes")
    @builtins.classmethod
    def from_aws_managed_component_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> "IComponent":
        '''(experimental) Imports an AWS-managed component from its attributes.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0eb8b88fb01463e77d65e8b3815c5fe4a9d52d5ed7d626bea7c9e5bdd7e3c933)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsManagedComponentAttributes(
            component_name=component_name,
            component_version=component_version,
            platform=platform,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "fromAwsManagedComponentAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="fromAwsManagedComponentName")
    @builtins.classmethod
    def from_aws_managed_component_name(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        aws_managed_component_name: builtins.str,
    ) -> "IComponent":
        '''(experimental) Imports an AWS-managed component from its name.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param aws_managed_component_name: - The name of the AWS-managed component.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1627b69c7ba0f04ae9ab6f1180bac6dcb468a367c684ce2ad9e056fe1b690dd7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument aws_managed_component_name", value=aws_managed_component_name, expected_type=type_hints["aws_managed_component_name"])
        return typing.cast("IComponent", jsii.sinvoke(cls, "fromAwsManagedComponentName", [scope, id, aws_managed_component_name]))

    @jsii.member(jsii_name="helloWorld")
    @builtins.classmethod
    def hello_world(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> "IComponent":
        '''(experimental) Imports the hello world AWS-managed component.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e95cc80beec8557aaefdf226beed47b803646d97e987b28db9a477824f800fe7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsManagedComponentAttributes(
            component_name=component_name,
            component_version=component_version,
            platform=platform,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "helloWorld", [scope, id, attrs]))

    @jsii.member(jsii_name="python3")
    @builtins.classmethod
    def python3(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> "IComponent":
        '''(experimental) Imports the Python 3 AWS-managed component.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b92acbc29e4089fea8f68555361bc22819eb5f63eadda40faf19d3a828fb29fc)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsManagedComponentAttributes(
            component_name=component_name,
            component_version=component_version,
            platform=platform,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "python3", [scope, id, attrs]))

    @jsii.member(jsii_name="reboot")
    @builtins.classmethod
    def reboot(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> "IComponent":
        '''(experimental) Imports the reboot AWS-managed component.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__69ab4d7f7fe572f41496187a8f5fd08b3dfdbbe78d1aa9cf5265d61d84e8ecbe)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsManagedComponentAttributes(
            component_name=component_name,
            component_version=component_version,
            platform=platform,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "reboot", [scope, id, attrs]))

    @jsii.member(jsii_name="stigBuild")
    @builtins.classmethod
    def stig_build(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> "IComponent":
        '''(experimental) Imports the STIG hardening AWS-managed component.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :see: https://docs.aws.amazon.com/imagebuilder/latest/userguide/ib-stig.html
        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ee53616f10cfba26195e210fe4dc7bcff71fa4a63c9e6648e4025ee62fafedcc)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsManagedComponentAttributes(
            component_name=component_name,
            component_version=component_version,
            platform=platform,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "stigBuild", [scope, id, attrs]))

    @jsii.member(jsii_name="updateOS")
    @builtins.classmethod
    def update_os(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> "IComponent":
        '''(experimental) Imports the OS update AWS-managed component.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d19311b8326a0517457ce310fe53e0167cc068a7f8d5c49cc1a577e6fa7d0cd2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsManagedComponentAttributes(
            component_name=component_name,
            component_version=component_version,
            platform=platform,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "updateOS", [scope, id, attrs]))


class _AwsManagedComponentProxy(AwsManagedComponent):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, AwsManagedComponent).__jsii_proxy_class__ = lambda : _AwsManagedComponentProxy


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.AwsManagedComponentAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "component_name": "componentName",
        "component_version": "componentVersion",
        "platform": "platform",
    },
)
class AwsManagedComponentAttributes:
    def __init__(
        self,
        *,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        platform: typing.Optional["Platform"] = None,
    ) -> None:
        '''(experimental) Properties for an EC2 Image Builder AWS-managed component.

        :param component_name: (experimental) The name of the AWS-managed component. The name of the AWS-managed component. This is a required attribute when using the ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. Default: - none if using the pre-defined managed component methods, otherwise a platform is required when using ``this.fromAwsManagedComponentAttributes()``
        :param component_version: (experimental) The version of the AWS-managed component. Default: - the latest version of the component, x.x.x
        :param platform: (experimental) The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method. Default: - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is required when using the pre-defined managed component methods

        :stability: experimental
        :exampleMetadata: infused

        Example::

            # Install AWS CLI v2
            aws_cli_component = imagebuilder.AwsManagedComponent.aws_cli_v2(self, "AwsCli",
                platform=imagebuilder.Platform.LINUX
            )
            
            # Update the operating system
            update_component = imagebuilder.AwsManagedComponent.update_oS(self, "UpdateOS",
                platform=imagebuilder.Platform.LINUX
            )
            
            # Reference any AWS-managed component by name
            custom_aws_component = imagebuilder.AwsManagedComponent.from_aws_managed_component_name(self, "CloudWatchAgent", "amazon-cloudwatch-agent-linux")
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32e146149e9a0c45e3993363b6a87d969c0d980b08ea6bb731b42f52f28c04dd)
            check_type(argname="argument component_name", value=component_name, expected_type=type_hints["component_name"])
            check_type(argname="argument component_version", value=component_version, expected_type=type_hints["component_version"])
            check_type(argname="argument platform", value=platform, expected_type=type_hints["platform"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if component_name is not None:
            self._values["component_name"] = component_name
        if component_version is not None:
            self._values["component_version"] = component_version
        if platform is not None:
            self._values["platform"] = platform

    @builtins.property
    def component_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the AWS-managed component.

        The name of the AWS-managed component. This is a required attribute when using the
        ``this.fromAwsManagedComponentAttributes()`` method. This parameter should not be provided when
        using the pre-defined managed component methods, such as ``AwsManagedComponent.updateOS()`` and
        ``AwsManagedComponent.reboot()``.

        :default:

        - none if using  the pre-defined managed component methods, otherwise a platform is required when using
        ``this.fromAwsManagedComponentAttributes()``

        :stability: experimental
        '''
        result = self._values.get("component_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def component_version(self) -> typing.Optional[builtins.str]:
        '''(experimental) The version of the AWS-managed component.

        :default: - the latest version of the component, x.x.x

        :stability: experimental
        '''
        result = self._values.get("component_version")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def platform(self) -> typing.Optional["Platform"]:
        '''(experimental) The platform of the AWS-managed component.

        This is a required attribute when using the pre-defined managed
        component methods, such as ``AwsManagedComponent.updateOS()`` and ``AwsManagedComponent.reboot()``. This parameter
        should not be provided when using the ``this.fromAwsManagedComponentAttributes()`` method.

        :default:

        - none if using ``this.fromAwsManagedComponentAttributes()``, otherwise a platform is
        required when using the pre-defined managed component methods

        :stability: experimental
        '''
        result = self._values.get("platform")
        return typing.cast(typing.Optional["Platform"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AwsManagedComponentAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AwsMarketplaceComponent(
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.AwsMarketplaceComponent",
):
    '''(experimental) Helper class for working with AWS Marketplace components.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        marketplace_component = imagebuilder.AwsMarketplaceComponent.from_aws_marketplace_component_attributes(self, "MarketplaceComponent",
            component_name="my-marketplace-component",
            marketplace_product_id="prod-1234567890abcdef0"
        )
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="fromAwsMarketplaceComponentAttributes")
    @builtins.classmethod
    def from_aws_marketplace_component_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_name: builtins.str,
        marketplace_product_id: builtins.str,
        component_version: typing.Optional[builtins.str] = None,
    ) -> "IComponent":
        '''(experimental) Imports an AWS Marketplace component from its attributes.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param component_name: (experimental) The name of the AWS Marketplace component. This name should exclude the marketplace product ID from it
        :param marketplace_product_id: (experimental) The marketplace product ID associated with the component.
        :param component_version: (experimental) The version of the AWS Marketplace component. Default: - the latest version of the component, x.x.x

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72fea4585ffbd64de79c39d71516ff9636b95dece6fff22dc33683909474b7ea)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = AwsMarketplaceComponentAttributes(
            component_name=component_name,
            marketplace_product_id=marketplace_product_id,
            component_version=component_version,
        )

        return typing.cast("IComponent", jsii.sinvoke(cls, "fromAwsMarketplaceComponentAttributes", [scope, id, attrs]))


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.AwsMarketplaceComponentAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "component_name": "componentName",
        "marketplace_product_id": "marketplaceProductId",
        "component_version": "componentVersion",
    },
)
class AwsMarketplaceComponentAttributes:
    def __init__(
        self,
        *,
        component_name: builtins.str,
        marketplace_product_id: builtins.str,
        component_version: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Properties for an EC2 Image Builder AWS Marketplace component.

        :param component_name: (experimental) The name of the AWS Marketplace component. This name should exclude the marketplace product ID from it
        :param marketplace_product_id: (experimental) The marketplace product ID associated with the component.
        :param component_version: (experimental) The version of the AWS Marketplace component. Default: - the latest version of the component, x.x.x

        :stability: experimental
        :exampleMetadata: infused

        Example::

            marketplace_component = imagebuilder.AwsMarketplaceComponent.from_aws_marketplace_component_attributes(self, "MarketplaceComponent",
                component_name="my-marketplace-component",
                marketplace_product_id="prod-1234567890abcdef0"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7239391743877da3432bdb2ba2d1e3c8b1e460c607e06086757dd481b60551dc)
            check_type(argname="argument component_name", value=component_name, expected_type=type_hints["component_name"])
            check_type(argname="argument marketplace_product_id", value=marketplace_product_id, expected_type=type_hints["marketplace_product_id"])
            check_type(argname="argument component_version", value=component_version, expected_type=type_hints["component_version"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "component_name": component_name,
            "marketplace_product_id": marketplace_product_id,
        }
        if component_version is not None:
            self._values["component_version"] = component_version

    @builtins.property
    def component_name(self) -> builtins.str:
        '''(experimental) The name of the AWS Marketplace component.

        This name should exclude the marketplace product ID from it

        :stability: experimental
        '''
        result = self._values.get("component_name")
        assert result is not None, "Required property 'component_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def marketplace_product_id(self) -> builtins.str:
        '''(experimental) The marketplace product ID associated with the component.

        :stability: experimental
        '''
        result = self._values.get("marketplace_product_id")
        assert result is not None, "Required property 'marketplace_product_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def component_version(self) -> typing.Optional[builtins.str]:
        '''(experimental) The version of the AWS Marketplace component.

        :default: - the latest version of the component, x.x.x

        :stability: experimental
        '''
        result = self._values.get("component_version")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AwsMarketplaceComponentAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentAction")
class ComponentAction(enum.Enum):
    '''(experimental) The action for a step within the component document.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        component = imagebuilder.Component(self, "MyComponent",
            platform=imagebuilder.Platform.LINUX,
            data=imagebuilder.ComponentData.from_json_object({
                "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
                "phases": [{
                    "name": imagebuilder.ComponentPhaseName.BUILD,
                    "steps": [{
                        "name": "install-app",
                        "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                        "inputs": {
                            "commands": ["echo \"Installing my application...\"", "yum update -y"]
                        }
                    }
                    ]
                }
                ]
            })
        )
    '''

    APPEND_FILE = "APPEND_FILE"
    '''(experimental) The AppendFile action adds the provided content to the pre-existing content of a file.

    :stability: experimental
    '''
    ASSERT = "ASSERT"
    '''(experimental) The Assert action performs value with comparison/logic operators, and succeeds/fails the step based on the outcome of the assertion.

    :stability: experimental
    '''
    COPY_FILE = "COPY_FILE"
    '''(experimental) The CopyFile action copies files from a source file to a destination.

    :stability: experimental
    '''
    COPY_FOLDER = "COPY_FOLDER"
    '''(experimental) The CopyFolder action copies folders from a source to a destination.

    :stability: experimental
    '''
    CREATE_FILE = "CREATE_FILE"
    '''(experimental) The CreateFile action creates a file in the provided location.

    :stability: experimental
    '''
    CREATE_FOLDER = "CREATE_FOLDER"
    '''(experimental) The CreateFolder action creates a folder in the provided location.

    :stability: experimental
    '''
    CREATE_SYMLINK = "CREATE_SYMLINK"
    '''(experimental) The CreateSymlink action creates symbolic links from a given path to a target.

    :stability: experimental
    '''
    DELETE_FILE = "DELETE_FILE"
    '''(experimental) The DeleteFile action deletes file(s) in the provided location.

    :stability: experimental
    '''
    DELETE_FOLDER = "DELETE_FOLDER"
    '''(experimental) The DeleteFolder action deletes folders in the provided location.

    :stability: experimental
    '''
    EXECUTE_BASH = "EXECUTE_BASH"
    '''(experimental) The ExecuteBash action runs bash scripts with inline bash commands.

    :stability: experimental
    '''
    EXECUTE_BINARY = "EXECUTE_BINARY"
    '''(experimental) The ExecuteBinary action runs a provided binary executable.

    :stability: experimental
    '''
    EXECUTE_DOCUMENT = "EXECUTE_DOCUMENT"
    '''(experimental) The ExecuteDocument action allows running other component documents from within a given component.

    :stability: experimental
    '''
    EXECUTE_POWERSHELL = "EXECUTE_POWERSHELL"
    '''(experimental) The ExecutePowershell action runs PowerShell scripts with inline PowerShell commands.

    :stability: experimental
    '''
    INSTALL_MSI = "INSTALL_MSI"
    '''(experimental) The InstallMSI action runs a Windows application with the provided MSI file.

    :stability: experimental
    '''
    LIST_FILES = "LIST_FILES"
    '''(experimental) The ListFiles action lists files in the provided folder.

    :stability: experimental
    '''
    MOVE_FILE = "MOVE_FILE"
    '''(experimental) The MoveFile action moves files from a source to a destination.

    :stability: experimental
    '''
    MOVE_FOLDER = "MOVE_FOLDER"
    '''(experimental) The MoveFolder action moves folders from a source to a destination.

    :stability: experimental
    '''
    READ_FILE = "READ_FILE"
    '''(experimental) The ReadFile action reads the content of a text file.

    :stability: experimental
    '''
    REBOOT = "REBOOT"
    '''(experimental) The Reboot action reboots the instance.

    :stability: experimental
    '''
    SET_FILE_ENCODING = "SET_FILE_ENCODING"
    '''(experimental) The SetFileEncoding action modifies the encoding property of an existing file.

    :stability: experimental
    '''
    SET_FILE_OWNER = "SET_FILE_OWNER"
    '''(experimental) The SetFileOwner action modifies the owner and group ownership properties of an existing file.

    :stability: experimental
    '''
    SET_FOLDER_OWNER = "SET_FOLDER_OWNER"
    '''(experimental) The SetFolderOwner action recursively modifies the owner and group ownership properties of an existing folder.

    :stability: experimental
    '''
    SET_FILE_PERMISSIONS = "SET_FILE_PERMISSIONS"
    '''(experimental) The SetFilePermissions action modifies the permission of an existing file.

    :stability: experimental
    '''
    SET_FOLDER_PERMISSIONS = "SET_FOLDER_PERMISSIONS"
    '''(experimental) The SetFolderPermissions action recursively modifies the permissions of an existing folder and all of its subfiles and subfolders.

    :stability: experimental
    '''
    SET_REGISTRY = "SET_REGISTRY"
    '''(experimental) The SetRegistry action sets the value for the specified Windows registry key.

    :stability: experimental
    '''
    S3_DOWNLOAD = "S3_DOWNLOAD"
    '''(experimental) The S3Download action downloads an Amazon S3 object/folder to a local destination.

    :stability: experimental
    '''
    S3_UPLOAD = "S3_UPLOAD"
    '''(experimental) The S3Upload action uploads a file or folder to an Amazon S3 location.

    :stability: experimental
    '''
    UNINSTALL_MSI = "UNINSTALL_MSI"
    '''(experimental) The UninstallMSI action removes a Windows application using an MSI file.

    :stability: experimental
    '''
    UPDATE_OS = "UPDATE_OS"
    '''(experimental) The UpdateOS action installs OS updates.

    :stability: experimental
    '''
    WEB_DOWNLOAD = "WEB_DOWNLOAD"
    '''(experimental) The WebDownload action downloads files from a URL to a local destination.

    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "component_arn": "componentArn",
        "component_name": "componentName",
        "component_version": "componentVersion",
    },
)
class ComponentAttributes:
    def __init__(
        self,
        *,
        component_arn: typing.Optional[builtins.str] = None,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Properties for an EC2 Image Builder component.

        :param component_arn: (experimental) The ARN of the component. Default: - the ARN is automatically constructed if a componentName is provided, otherwise a componentArn is required
        :param component_name: (experimental) The name of the component. Default: - the name is automatically constructed if a componentArn is provided, otherwise a componentName is required
        :param component_version: (experimental) The version of the component. Default: - the latest version of the component, x.x.x

        :stability: experimental
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
            
            component_attributes = imagebuilder_alpha.ComponentAttributes(
                component_arn="componentArn",
                component_name="componentName",
                component_version="componentVersion"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a111ce6a3cc980fdfd78a9c04008d2621e0cdb5a73ac895dcac5188565ad834a)
            check_type(argname="argument component_arn", value=component_arn, expected_type=type_hints["component_arn"])
            check_type(argname="argument component_name", value=component_name, expected_type=type_hints["component_name"])
            check_type(argname="argument component_version", value=component_version, expected_type=type_hints["component_version"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if component_arn is not None:
            self._values["component_arn"] = component_arn
        if component_name is not None:
            self._values["component_name"] = component_name
        if component_version is not None:
            self._values["component_version"] = component_version

    @builtins.property
    def component_arn(self) -> typing.Optional[builtins.str]:
        '''(experimental) The ARN of the component.

        :default:

        - the ARN is automatically constructed if a componentName is provided, otherwise a componentArn is
        required

        :stability: experimental
        '''
        result = self._values.get("component_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def component_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the component.

        :default:

        - the name is automatically constructed if a componentArn is provided, otherwise a componentName is
        required

        :stability: experimental
        '''
        result = self._values.get("component_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def component_version(self) -> typing.Optional[builtins.str]:
        '''(experimental) The version of the component.

        :default: - the latest version of the component, x.x.x

        :stability: experimental
        '''
        result = self._values.get("component_version")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ComponentConstantValue(
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentConstantValue",
):
    '''(experimental) The value of a constant in a component document.

    :stability: experimental
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
        
        component_constant_value = imagebuilder_alpha.ComponentConstantValue.from_string("value")
    '''

    def __init__(self, type: builtins.str, value: typing.Any) -> None:
        '''
        :param type: -
        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7a022302a19d26bbe18edf3fafb69d72fca2ee4e1f292dafa9ce24d08a9455c)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.create(self.__class__, self, [type, value])

    @jsii.member(jsii_name="fromString")
    @builtins.classmethod
    def from_string(cls, value: builtins.str) -> "ComponentConstantValue":
        '''(experimental) Creates a string type constant in a component document.

        :param value: The value of the constant.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__963a239c9c403fc6b5a4313e8e62b5aa83e3dfcb87d450ca08bbee183cbac1d4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        return typing.cast("ComponentConstantValue", jsii.sinvoke(cls, "fromString", [value]))

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''(experimental) The data type of the constant.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "type"))

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> typing.Any:
        '''(experimental) The value of the constant.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "value"))


class ComponentData(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentData",
):
    '''(experimental) Helper class for referencing and uploading component data.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        component = imagebuilder.Component(self, "MyComponent",
            platform=imagebuilder.Platform.LINUX,
            data=imagebuilder.ComponentData.from_json_object({
                "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
                "phases": [{
                    "name": imagebuilder.ComponentPhaseName.BUILD,
                    "steps": [{
                        "name": "install-app",
                        "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                        "inputs": {
                            "commands": ["echo \"Installing my application...\"", "yum update -y"]
                        }
                    }
                    ]
                }
                ]
            })
        )
    '''

    def __init__(self, value: builtins.str) -> None:
        '''
        :param value: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__edbe027f8c3d7062dfc1c03bb55eb927c328b9cd602143575a35fa311f551f29)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.create(self.__class__, self, [value])

    @jsii.member(jsii_name="fromAsset")
    @builtins.classmethod
    def from_asset(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        path: builtins.str,
        *,
        deploy_time: typing.Optional[builtins.bool] = None,
        display_name: typing.Optional[builtins.str] = None,
        readers: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.IGrantable]] = None,
        source_kms_key: typing.Optional[_aws_cdk_interfaces_aws_kms_ceddda9d.IKeyRef] = None,
        asset_hash: typing.Optional[builtins.str] = None,
        asset_hash_type: typing.Optional[_aws_cdk_ceddda9d.AssetHashType] = None,
        bundling: typing.Optional[typing.Union[_aws_cdk_ceddda9d.BundlingOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
        follow_symlinks: typing.Optional[_aws_cdk_ceddda9d.SymlinkFollowMode] = None,
        ignore_mode: typing.Optional[_aws_cdk_ceddda9d.IgnoreMode] = None,
    ) -> "S3ComponentData":
        '''(experimental) Uploads component data from a local file to S3 to use as the component data.

        :param scope: The construct scope.
        :param id: Identifier of the construct.
        :param path: The local path to the component data file.
        :param deploy_time: Whether or not the asset needs to exist beyond deployment time; i.e. are copied over to a different location and not needed afterwards. Setting this property to true has an impact on the lifecycle of the asset, because we will assume that it is safe to delete after the CloudFormation deployment succeeds. For example, Lambda Function assets are copied over to Lambda during deployment. Therefore, it is not necessary to store the asset in S3, so we consider those deployTime assets. Default: false
        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. If the same asset is added multiple times, the display name of the first occurrence is used. The default is the construct path of the Asset construct, with respect to the enclosing stack. If the asset is produced by a construct helper function (such as ``lambda.Code.fromAsset()``), this will look like ``MyFunction/Code``. We use the stack-relative construct path so that in the common case where you have multiple stacks with the same asset, we won't show something like ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to production. Default: - Stack-relative construct path
        :param readers: A list of principals that should be able to read this asset from S3. You can use ``asset.grantRead(principal)`` to grant read permissions later. Default: - No principals that can read file asset.
        :param source_kms_key: The ARN of the KMS key used to encrypt the handler code. Default: - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.
        :param asset_hash: Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be the asset hash. NOTE: the hash is used in order to identify a specific revision of the asset, and used for optimizing and caching deployment activities related to this asset such as packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will need to make sure it is updated every time the asset changes, or otherwise it is possible that some deployments will not be invalidated. Default: - based on ``assetHashType``
        :param asset_hash_type: Specifies the type of hash to calculate for this asset. If ``assetHash`` is configured, this option must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
        :param bundling: Bundle the asset by executing a command in a Docker container or a custom bundling provider. The asset path will be mounted at ``/asset-input``. The Docker container is responsible for putting content at ``/asset-output``. The content at ``/asset-output`` will be zipped and used as the final asset. Default: - uploaded as-is to S3 if the asset is a regular file or a .zip file, archived into a .zip file and uploaded to S3 otherwise
        :param exclude: File paths matching the patterns will be excluded. See ``ignoreMode`` to set the matching behavior. Has no effect on Assets bundled using the ``bundling`` property. Default: - nothing is excluded
        :param follow_symlinks: A strategy for how to handle symlinks. Default: SymlinkFollowMode.NEVER
        :param ignore_mode: The ignore behavior to use for ``exclude`` patterns. Default: IgnoreMode.GLOB

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3dd9994d6bd946b1ceac062da8831ad7f0ab68167221bcb1de2b5bf4f1b9389)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        options = _aws_cdk_aws_s3_assets_ceddda9d.AssetOptions(
            deploy_time=deploy_time,
            display_name=display_name,
            readers=readers,
            source_kms_key=source_kms_key,
            asset_hash=asset_hash,
            asset_hash_type=asset_hash_type,
            bundling=bundling,
            exclude=exclude,
            follow_symlinks=follow_symlinks,
            ignore_mode=ignore_mode,
        )

        return typing.cast("S3ComponentData", jsii.sinvoke(cls, "fromAsset", [scope, id, path, options]))

    @jsii.member(jsii_name="fromComponentDocumentJsonObject")
    @builtins.classmethod
    def from_component_document_json_object(
        cls,
        *,
        phases: typing.Sequence[typing.Union["ComponentDocumentPhase", typing.Dict[builtins.str, typing.Any]]],
        schema_version: "ComponentSchemaVersion",
        constants: typing.Optional[typing.Mapping[builtins.str, ComponentConstantValue]] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        parameters: typing.Optional[typing.Mapping[builtins.str, typing.Union["ComponentDocumentParameterDefinition", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> "ComponentData":
        '''(experimental) Uses an inline JSON object as the component data, using the ComponentDocument interface.

        :param phases: (experimental) The phases which define the grouping of steps to run in the build and test workflows of the image build.
        :param schema_version: (experimental) The schema version of the component.
        :param constants: (experimental) The constants to define in the document. Default: None
        :param description: (experimental) The description of the document. Default: None
        :param name: (experimental) The name of the document. Default: None
        :param parameters: (experimental) The parameters to define in the document. Default: None

        :stability: experimental
        '''
        data = ComponentDocument(
            phases=phases,
            schema_version=schema_version,
            constants=constants,
            description=description,
            name=name,
            parameters=parameters,
        )

        return typing.cast("ComponentData", jsii.sinvoke(cls, "fromComponentDocumentJsonObject", [data]))

    @jsii.member(jsii_name="fromInline")
    @builtins.classmethod
    def from_inline(cls, data: builtins.str) -> "ComponentData":
        '''(experimental) Uses an inline JSON/YAML string as the component data.

        :param data: An inline JSON/YAML string representing the component data.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e5c968d474a4be4f05abdfab6bd5b4d52a49ade7db8a0614bd22bc59fe1dbb4)
            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
        return typing.cast("ComponentData", jsii.sinvoke(cls, "fromInline", [data]))

    @jsii.member(jsii_name="fromJsonObject")
    @builtins.classmethod
    def from_json_object(
        cls,
        data: typing.Mapping[builtins.str, typing.Any],
    ) -> "ComponentData":
        '''(experimental) Uses an inline JSON object as the component data.

        :param data: An inline JSON object representing the component data.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e62d9de5f9eddd59dcfb4d4419326a2af5a8035493101b1595b1a55234425ab)
            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
        return typing.cast("ComponentData", jsii.sinvoke(cls, "fromJsonObject", [data]))

    @jsii.member(jsii_name="fromS3")
    @builtins.classmethod
    def from_s3(
        cls,
        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        key: builtins.str,
    ) -> "S3ComponentData":
        '''(experimental) References component data from a pre-existing S3 object.

        :param bucket: The S3 bucket where the component data is stored.
        :param key: The S3 key of the component data file.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__502ae41b418b170f33bf886f3f817d134270c2d3c6d326d7017b7da013816b35)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        return typing.cast("S3ComponentData", jsii.sinvoke(cls, "fromS3", [bucket, key]))

    @builtins.property
    @jsii.member(jsii_name="isS3Reference")
    @abc.abstractmethod
    def is_s3_reference(self) -> builtins.bool:
        '''(experimental) Indicates that the provided component data is an S3 reference.

        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> builtins.str:
        '''(experimental) The resulting inline string or S3 URL which references the component data.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "value"))


class _ComponentDataProxy(ComponentData):
    @builtins.property
    @jsii.member(jsii_name="isS3Reference")
    def is_s3_reference(self) -> builtins.bool:
        '''(experimental) Indicates that the provided component data is an S3 reference.

        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "isS3Reference"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, ComponentData).__jsii_proxy_class__ = lambda : _ComponentDataProxy


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentDocument",
    jsii_struct_bases=[],
    name_mapping={
        "phases": "phases",
        "schema_version": "schemaVersion",
        "constants": "constants",
        "description": "description",
        "name": "name",
        "parameters": "parameters",
    },
)
class ComponentDocument:
    def __init__(
        self,
        *,
        phases: typing.Sequence[typing.Union["ComponentDocumentPhase", typing.Dict[builtins.str, typing.Any]]],
        schema_version: "ComponentSchemaVersion",
        constants: typing.Optional[typing.Mapping[builtins.str, ComponentConstantValue]] = None,
        description: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        parameters: typing.Optional[typing.Mapping[builtins.str, typing.Union["ComponentDocumentParameterDefinition", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''(experimental) Properties of an EC2 Image Builder Component Document.

        :param phases: (experimental) The phases which define the grouping of steps to run in the build and test workflows of the image build.
        :param schema_version: (experimental) The schema version of the component.
        :param constants: (experimental) The constants to define in the document. Default: None
        :param description: (experimental) The description of the document. Default: None
        :param name: (experimental) The name of the document. Default: None
        :param parameters: (experimental) The parameters to define in the document. Default: None

        :stability: experimental
        :exampleMetadata: infused

        Example::

            component = imagebuilder.Component(self, "StructuredComponent",
                platform=imagebuilder.Platform.LINUX,
                data=imagebuilder.ComponentData.from_component_document_json_object(
                    schema_version=imagebuilder.ComponentSchemaVersion.V1_0,
                    phases=[imagebuilder.ComponentDocumentPhase(
                        name=imagebuilder.ComponentPhaseName.BUILD,
                        steps=[imagebuilder.ComponentDocumentStep(
                            name="install-with-timeout",
                            action=imagebuilder.ComponentAction.EXECUTE_BASH,
                            timeout=Duration.minutes(10),
                            on_failure=imagebuilder.ComponentOnFailure.CONTINUE,
                            inputs=imagebuilder.ComponentStepInputs.from_object({
                                "commands": ["./install-script.sh"]
                            })
                        )
                        ]
                    )
                    ]
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4737aa013938586441da1b86dab7eebc204c3816be9ffb4b4666db7f4c154a3c)
            check_type(argname="argument phases", value=phases, expected_type=type_hints["phases"])
            check_type(argname="argument schema_version", value=schema_version, expected_type=type_hints["schema_version"])
            check_type(argname="argument constants", value=constants, expected_type=type_hints["constants"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "phases": phases,
            "schema_version": schema_version,
        }
        if constants is not None:
            self._values["constants"] = constants
        if description is not None:
            self._values["description"] = description
        if name is not None:
            self._values["name"] = name
        if parameters is not None:
            self._values["parameters"] = parameters

    @builtins.property
    def phases(self) -> typing.List["ComponentDocumentPhase"]:
        '''(experimental) The phases which define the grouping of steps to run in the build and test workflows of the image build.

        :stability: experimental
        '''
        result = self._values.get("phases")
        assert result is not None, "Required property 'phases' is missing"
        return typing.cast(typing.List["ComponentDocumentPhase"], result)

    @builtins.property
    def schema_version(self) -> "ComponentSchemaVersion":
        '''(experimental) The schema version of the component.

        :stability: experimental
        '''
        result = self._values.get("schema_version")
        assert result is not None, "Required property 'schema_version' is missing"
        return typing.cast("ComponentSchemaVersion", result)

    @builtins.property
    def constants(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, ComponentConstantValue]]:
        '''(experimental) The constants to define in the document.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("constants")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, ComponentConstantValue]], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The description of the document.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the document.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def parameters(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "ComponentDocumentParameterDefinition"]]:
        '''(experimental) The parameters to define in the document.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("parameters")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "ComponentDocumentParameterDefinition"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentDocument(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentDocumentForLoop",
    jsii_struct_bases=[],
    name_mapping={"end": "end", "start": "start", "update_by": "updateBy"},
)
class ComponentDocumentForLoop:
    def __init__(
        self,
        *,
        end: jsii.Number,
        start: jsii.Number,
        update_by: jsii.Number,
    ) -> None:
        '''(experimental) The for loop iterates on a range of integers specified within a boundary outlined by the start and end of the variables.

        The iterating values are in the set [start, end] and includes boundary values.

        :param end: (experimental) Ending value of iteration. Does not accept chaining expressions.
        :param start: (experimental) Starting value of iteration. Does not accept chaining expressions.
        :param update_by: (experimental) Difference by which an iterating value is updated through addition. It must be a negative or positive non-zero value. Does not accept chaining expressions.

        :stability: experimental
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
            
            component_document_for_loop = imagebuilder_alpha.ComponentDocumentForLoop(
                end=123,
                start=123,
                update_by=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7545616e7ad4244bf8e5212a06dc04473a71fef0517840bdfaf4168ea419c44)
            check_type(argname="argument end", value=end, expected_type=type_hints["end"])
            check_type(argname="argument start", value=start, expected_type=type_hints["start"])
            check_type(argname="argument update_by", value=update_by, expected_type=type_hints["update_by"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "end": end,
            "start": start,
            "update_by": update_by,
        }

    @builtins.property
    def end(self) -> jsii.Number:
        '''(experimental) Ending value of iteration.

        Does not accept chaining expressions.

        :stability: experimental
        '''
        result = self._values.get("end")
        assert result is not None, "Required property 'end' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def start(self) -> jsii.Number:
        '''(experimental) Starting value of iteration.

        Does not accept chaining expressions.

        :stability: experimental
        '''
        result = self._values.get("start")
        assert result is not None, "Required property 'start' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def update_by(self) -> jsii.Number:
        '''(experimental) Difference by which an iterating value is updated through addition.

        It must be a negative or positive non-zero
        value. Does not accept chaining expressions.

        :stability: experimental
        '''
        result = self._values.get("update_by")
        assert result is not None, "Required property 'update_by' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentDocumentForLoop(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentDocumentLoop",
    jsii_struct_bases=[],
    name_mapping={"for_": "for", "for_each": "forEach", "name": "name"},
)
class ComponentDocumentLoop:
    def __init__(
        self,
        *,
        for_: typing.Optional[typing.Union[ComponentDocumentForLoop, typing.Dict[builtins.str, typing.Any]]] = None,
        for_each: typing.Optional[typing.Sequence[builtins.str]] = None,
        name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The looping construct of a component defines a repeated sequence of instructions.

        :param for_: (experimental) The for loop iterates on a range of integers specified within a boundary outlined by the start and end of the variables. Default: - none if ``forEach`` is provided. otherwise, ``for`` is required.
        :param for_each: (experimental) The forEach loop iterates on an explicit list of values, which can be strings and chained expressions. Default: - none if ``for`` is provided. otherwise, ``forEach`` is required.
        :param name: (experimental) The name of the loop, which can be used to reference. Default: loop

        :stability: experimental
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
            
            component_document_loop = imagebuilder_alpha.ComponentDocumentLoop(
                for=imagebuilder_alpha.ComponentDocumentForLoop(
                    end=123,
                    start=123,
                    update_by=123
                ),
                for_each=["forEach"],
                name="name"
            )
        '''
        if isinstance(for_, dict):
            for_ = ComponentDocumentForLoop(**for_)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__016c7a2af8ebcf03286820555388bbfa1ccb89028f5f37b87fa3f7cb9dceded7)
            check_type(argname="argument for_", value=for_, expected_type=type_hints["for_"])
            check_type(argname="argument for_each", value=for_each, expected_type=type_hints["for_each"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if for_ is not None:
            self._values["for_"] = for_
        if for_each is not None:
            self._values["for_each"] = for_each
        if name is not None:
            self._values["name"] = name

    @builtins.property
    def for_(self) -> typing.Optional[ComponentDocumentForLoop]:
        '''(experimental) The for loop iterates on a range of integers specified within a boundary outlined by the start and end of the variables.

        :default: - none if ``forEach`` is provided. otherwise, ``for`` is required.

        :stability: experimental
        '''
        result = self._values.get("for_")
        return typing.cast(typing.Optional[ComponentDocumentForLoop], result)

    @builtins.property
    def for_each(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) The forEach loop iterates on an explicit list of values, which can be strings and chained expressions.

        :default: - none if ``for`` is provided. otherwise, ``forEach`` is required.

        :stability: experimental
        '''
        result = self._values.get("for_each")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the loop, which can be used to reference.

        :default: loop

        :stability: experimental
        '''
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentDocumentLoop(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentDocumentParameterDefinition",
    jsii_struct_bases=[],
    name_mapping={"type": "type", "default": "default", "description": "description"},
)
class ComponentDocumentParameterDefinition:
    def __init__(
        self,
        *,
        type: "ComponentParameterType",
        default: typing.Any = None,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The definition of the parameter.

        :param type: (experimental) The type of the parameter.
        :param default: (experimental) The default value of the parameter. Default: - none, indicating the parameter is required
        :param description: (experimental) The description of the parameter. Default: None

        :stability: experimental
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
            
            # default_: Any
            
            component_document_parameter_definition = imagebuilder_alpha.ComponentDocumentParameterDefinition(
                type=imagebuilder_alpha.ComponentParameterType.STRING,
            
                # the properties below are optional
                default=default_,
                description="description"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7b765c0d6f7d805699670929833be905f563259a2aec778f1d09ab1ac16f76c5)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument default", value=default, expected_type=type_hints["default"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "type": type,
        }
        if default is not None:
            self._values["default"] = default
        if description is not None:
            self._values["description"] = description

    @builtins.property
    def type(self) -> "ComponentParameterType":
        '''(experimental) The type of the parameter.

        :stability: experimental
        '''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast("ComponentParameterType", result)

    @builtins.property
    def default(self) -> typing.Any:
        '''(experimental) The default value of the parameter.

        :default: - none, indicating the parameter is required

        :stability: experimental
        '''
        result = self._values.get("default")
        return typing.cast(typing.Any, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The description of the parameter.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentDocumentParameterDefinition(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentDocumentPhase",
    jsii_struct_bases=[],
    name_mapping={"name": "name", "steps": "steps"},
)
class ComponentDocumentPhase:
    def __init__(
        self,
        *,
        name: "ComponentPhaseName",
        steps: typing.Sequence[typing.Union["ComponentDocumentStep", typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''(experimental) The phase to run in a specific workflow in an image build, which define the steps to execute to customize or test the instance.

        :param name: (experimental) The name of the phase.
        :param steps: (experimental) The list of steps to execute to modify or test the build/test instance.

        :stability: experimental
        :exampleMetadata: infused

        Example::

            phase = imagebuilder.ComponentDocumentPhase(
                name=imagebuilder.ComponentPhaseName.BUILD,
                steps=[imagebuilder.ComponentDocumentStep(
                    name="configure-app",
                    action=imagebuilder.ComponentAction.CREATE_FILE,
                    inputs=imagebuilder.ComponentStepInputs.from_object({
                        "path": "/etc/myapp/config.json",
                        "content": "{\"env\": \"production\"}"
                    })
                )
                ]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3717a69557789288ecb2866be7254e9e0d4db1c92bd936b8be1466c3858d8a51)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument steps", value=steps, expected_type=type_hints["steps"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "name": name,
            "steps": steps,
        }

    @builtins.property
    def name(self) -> "ComponentPhaseName":
        '''(experimental) The name of the phase.

        :stability: experimental
        '''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast("ComponentPhaseName", result)

    @builtins.property
    def steps(self) -> typing.List["ComponentDocumentStep"]:
        '''(experimental) The list of steps to execute to modify or test the build/test instance.

        :stability: experimental
        '''
        result = self._values.get("steps")
        assert result is not None, "Required property 'steps' is missing"
        return typing.cast(typing.List["ComponentDocumentStep"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentDocumentPhase(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentDocumentStep",
    jsii_struct_bases=[],
    name_mapping={
        "action": "action",
        "inputs": "inputs",
        "name": "name",
        "if_": "if",
        "loop": "loop",
        "on_failure": "onFailure",
        "timeout": "timeout",
    },
)
class ComponentDocumentStep:
    def __init__(
        self,
        *,
        action: ComponentAction,
        inputs: "ComponentStepInputs",
        name: builtins.str,
        if_: typing.Optional["ComponentStepIfCondition"] = None,
        loop: typing.Optional[typing.Union[ComponentDocumentLoop, typing.Dict[builtins.str, typing.Any]]] = None,
        on_failure: typing.Optional["ComponentOnFailure"] = None,
        timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    ) -> None:
        '''(experimental) The step to run in a specific phase of the image build, which defines the step to execute to customize or test the instance.

        :param action: (experimental) The action to perform in the step.
        :param inputs: (experimental) Contains parameters required by the action to run the step.
        :param name: (experimental) The name of the step.
        :param if_: (experimental) The condition to apply to the step. If the condition is false, then the step is skipped Default: - no condition is applied to the step and it gets executed
        :param loop: (experimental) A looping construct defining a repeated sequence of instructions. Default: None
        :param on_failure: (experimental) Specifies what the step should do in case of failure. Default: ComponentOnFailure.ABORT
        :param timeout: (experimental) The timeout of the step. Default: - 120 minutes

        :stability: experimental
        :exampleMetadata: infused

        Example::

            step = imagebuilder.ComponentDocumentStep(
                name="configure-app",
                action=imagebuilder.ComponentAction.CREATE_FILE,
                inputs=imagebuilder.ComponentStepInputs.from_object({
                    "path": "/etc/myapp/config.json",
                    "content": "{\"env\": \"production\"}"
                })
            )
        '''
        if isinstance(loop, dict):
            loop = ComponentDocumentLoop(**loop)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__da991558ffc8ca306ecc6999d0b287568416629c1073bde551fb7c089193ce5c)
            check_type(argname="argument action", value=action, expected_type=type_hints["action"])
            check_type(argname="argument inputs", value=inputs, expected_type=type_hints["inputs"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument if_", value=if_, expected_type=type_hints["if_"])
            check_type(argname="argument loop", value=loop, expected_type=type_hints["loop"])
            check_type(argname="argument on_failure", value=on_failure, expected_type=type_hints["on_failure"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "action": action,
            "inputs": inputs,
            "name": name,
        }
        if if_ is not None:
            self._values["if_"] = if_
        if loop is not None:
            self._values["loop"] = loop
        if on_failure is not None:
            self._values["on_failure"] = on_failure
        if timeout is not None:
            self._values["timeout"] = timeout

    @builtins.property
    def action(self) -> ComponentAction:
        '''(experimental) The action to perform in the step.

        :stability: experimental
        '''
        result = self._values.get("action")
        assert result is not None, "Required property 'action' is missing"
        return typing.cast(ComponentAction, result)

    @builtins.property
    def inputs(self) -> "ComponentStepInputs":
        '''(experimental) Contains parameters required by the action to run the step.

        :see: https://docs.aws.amazon.com/imagebuilder/latest/userguide/toe-action-modules.html
        :stability: experimental
        '''
        result = self._values.get("inputs")
        assert result is not None, "Required property 'inputs' is missing"
        return typing.cast("ComponentStepInputs", result)

    @builtins.property
    def name(self) -> builtins.str:
        '''(experimental) The name of the step.

        :stability: experimental
        '''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def if_(self) -> typing.Optional["ComponentStepIfCondition"]:
        '''(experimental) The condition to apply to the step.

        If the condition is false, then the step is skipped

        :default: - no condition is applied to the step and it gets executed

        :see: https://docs.aws.amazon.com/imagebuilder/latest/userguide/toe-comparison-operators.html
        :stability: experimental
        '''
        result = self._values.get("if_")
        return typing.cast(typing.Optional["ComponentStepIfCondition"], result)

    @builtins.property
    def loop(self) -> typing.Optional[ComponentDocumentLoop]:
        '''(experimental) A looping construct defining a repeated sequence of instructions.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("loop")
        return typing.cast(typing.Optional[ComponentDocumentLoop], result)

    @builtins.property
    def on_failure(self) -> typing.Optional["ComponentOnFailure"]:
        '''(experimental) Specifies what the step should do in case of failure.

        :default: ComponentOnFailure.ABORT

        :stability: experimental
        '''
        result = self._values.get("on_failure")
        return typing.cast(typing.Optional["ComponentOnFailure"], result)

    @builtins.property
    def timeout(self) -> typing.Optional[_aws_cdk_ceddda9d.Duration]:
        '''(experimental) The timeout of the step.

        :default: - 120 minutes

        :stability: experimental
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.Duration], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentDocumentStep(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentOnFailure")
class ComponentOnFailure(enum.Enum):
    '''(experimental) Specifies what the step should do in case of failure.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        component = imagebuilder.Component(self, "StructuredComponent",
            platform=imagebuilder.Platform.LINUX,
            data=imagebuilder.ComponentData.from_component_document_json_object(
                schema_version=imagebuilder.ComponentSchemaVersion.V1_0,
                phases=[imagebuilder.ComponentDocumentPhase(
                    name=imagebuilder.ComponentPhaseName.BUILD,
                    steps=[imagebuilder.ComponentDocumentStep(
                        name="install-with-timeout",
                        action=imagebuilder.ComponentAction.EXECUTE_BASH,
                        timeout=Duration.minutes(10),
                        on_failure=imagebuilder.ComponentOnFailure.CONTINUE,
                        inputs=imagebuilder.ComponentStepInputs.from_object({
                            "commands": ["./install-script.sh"]
                        })
                    )
                    ]
                )
                ]
            )
        )
    '''

    ABORT = "ABORT"
    '''(experimental) Fails the step and document execution.

    :stability: experimental
    '''
    CONTINUE = "CONTINUE"
    '''(experimental) Fails the step and proceeds to execute the next step in the document.

    :stability: experimental
    '''
    IGNORE = "IGNORE"
    '''(experimental) Ignores the step and proceeds to execute the next step in the document.

    :stability: experimental
    '''


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentParameterType")
class ComponentParameterType(enum.Enum):
    '''(experimental) The parameter type in a component document.

    :stability: experimental
    '''

    STRING = "STRING"
    '''(experimental) Indicates the parameter value is a string.

    :stability: experimental
    '''


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentPhaseName")
class ComponentPhaseName(enum.Enum):
    '''(experimental) The phases of a component document.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        component = imagebuilder.Component(self, "JsonComponent",
            platform=imagebuilder.Platform.LINUX,
            data=imagebuilder.ComponentData.from_json_object({
                "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
                "phases": [{
                    "name": imagebuilder.ComponentPhaseName.BUILD,
                    "steps": [{
                        "name": "configure-app",
                        "action": imagebuilder.ComponentAction.CREATE_FILE,
                        "inputs": {
                            "path": "/etc/myapp/config.json",
                            "content": "{\"env\": \"production\"}"
                        }
                    }
                    ]
                }
                ]
            })
        )
    '''

    BUILD = "BUILD"
    '''(experimental) Build phase of the component.

    This phase is run during the BUILDING phase of the image build.

    :stability: experimental
    '''
    CONTAINER_HOST_TEST = "CONTAINER_HOST_TEST"
    '''(experimental) Test phase of the component, executed directly on the instance which is used to build the container image.

    This
    phase is run during the TESTING phase of the image build.

    :stability: experimental
    '''
    TEST = "TEST"
    '''(experimental) Test phase of the component.

    This phase is run during the TESTING phase of the image build.

    :stability: experimental
    '''
    VALIDATE = "VALIDATE"
    '''(experimental) Validate phase of the component.

    This phase is run during the BUILDING phase of the image build, after the build
    step of the component is executed.

    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentProps",
    jsii_struct_bases=[],
    name_mapping={
        "data": "data",
        "platform": "platform",
        "change_description": "changeDescription",
        "component_name": "componentName",
        "component_version": "componentVersion",
        "description": "description",
        "kms_key": "kmsKey",
        "supported_os_versions": "supportedOsVersions",
        "tags": "tags",
    },
)
class ComponentProps:
    def __init__(
        self,
        *,
        data: ComponentData,
        platform: "Platform",
        change_description: typing.Optional[builtins.str] = None,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
        supported_os_versions: typing.Optional[typing.Sequence["OSVersion"]] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ) -> None:
        '''(experimental) Properties for creating a Component resource.

        :param data: (experimental) The component document content that defines the build, validation, or test steps to be executed during the image building process.
        :param platform: (experimental) The operating system platform of the component.
        :param change_description: (experimental) The change description of the component. Describes what change has been made in this version of the component, or what makes this version different from other versions. Default: None
        :param component_name: (experimental) The name of the component. Default: - a name is generated
        :param component_version: (experimental) The version of the component. Default: 1.0.0
        :param description: (experimental) The description of the component. Default: None
        :param kms_key: (experimental) The KMS key used to encrypt this component. Default: - an Image Builder owned key will be used to encrypt the component.
        :param supported_os_versions: (experimental) The operating system versions supported by the component. Default: None
        :param tags: (experimental) The tags to apply to the component. Default: None

        :stability: experimental
        :exampleMetadata: infused

        Example::

            component = imagebuilder.Component(self, "MyComponent",
                platform=imagebuilder.Platform.LINUX,
                data=imagebuilder.ComponentData.from_json_object({
                    "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
                    "phases": [{
                        "name": imagebuilder.ComponentPhaseName.BUILD,
                        "steps": [{
                            "name": "install-app",
                            "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                            "inputs": {
                                "commands": ["echo \"Installing my application...\"", "yum update -y"]
                            }
                        }
                        ]
                    }
                    ]
                })
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dafb5f8cd0f4ef40e1c882755f37fc5dc1a69e4a81d5826049e0c91bf971be3a)
            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
            check_type(argname="argument platform", value=platform, expected_type=type_hints["platform"])
            check_type(argname="argument change_description", value=change_description, expected_type=type_hints["change_description"])
            check_type(argname="argument component_name", value=component_name, expected_type=type_hints["component_name"])
            check_type(argname="argument component_version", value=component_version, expected_type=type_hints["component_version"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument kms_key", value=kms_key, expected_type=type_hints["kms_key"])
            check_type(argname="argument supported_os_versions", value=supported_os_versions, expected_type=type_hints["supported_os_versions"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "data": data,
            "platform": platform,
        }
        if change_description is not None:
            self._values["change_description"] = change_description
        if component_name is not None:
            self._values["component_name"] = component_name
        if component_version is not None:
            self._values["component_version"] = component_version
        if description is not None:
            self._values["description"] = description
        if kms_key is not None:
            self._values["kms_key"] = kms_key
        if supported_os_versions is not None:
            self._values["supported_os_versions"] = supported_os_versions
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def data(self) -> ComponentData:
        '''(experimental) The component document content that defines the build, validation, or test steps to be executed during the image building process.

        :stability: experimental
        '''
        result = self._values.get("data")
        assert result is not None, "Required property 'data' is missing"
        return typing.cast(ComponentData, result)

    @builtins.property
    def platform(self) -> "Platform":
        '''(experimental) The operating system platform of the component.

        :stability: experimental
        '''
        result = self._values.get("platform")
        assert result is not None, "Required property 'platform' is missing"
        return typing.cast("Platform", result)

    @builtins.property
    def change_description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The change description of the component.

        Describes what change has been made in this version of the component, or
        what makes this version different from other versions.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("change_description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def component_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the component.

        :default: - a name is generated

        :stability: experimental
        '''
        result = self._values.get("component_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def component_version(self) -> typing.Optional[builtins.str]:
        '''(experimental) The version of the component.

        :default: 1.0.0

        :stability: experimental
        '''
        result = self._values.get("component_version")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The description of the component.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def kms_key(self) -> typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey]:
        '''(experimental) The KMS key used to encrypt this component.

        :default: - an Image Builder owned key will be used to encrypt the component.

        :stability: experimental
        '''
        result = self._values.get("kms_key")
        return typing.cast(typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey], result)

    @builtins.property
    def supported_os_versions(self) -> typing.Optional[typing.List["OSVersion"]]:
        '''(experimental) The operating system versions supported by the component.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("supported_os_versions")
        return typing.cast(typing.Optional[typing.List["OSVersion"]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(experimental) The tags to apply to the component.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ComponentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentSchemaVersion")
class ComponentSchemaVersion(enum.Enum):
    '''(experimental) The schema version of the component.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        component = imagebuilder.Component(self, "EncryptedComponent",
            platform=imagebuilder.Platform.LINUX,
            kms_key=kms.Key(self, "ComponentKey"),
            data=imagebuilder.ComponentData.from_json_object({
                "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
                "phases": [{
                    "name": imagebuilder.ComponentPhaseName.BUILD,
                    "steps": [{
                        "name": "secure-setup",
                        "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                        "inputs": {
                            "commands": ["echo \"This component data is encrypted with KMS\""]
                        }
                    }
                    ]
                }
                ]
            })
        )
    '''

    V1_0 = "V1_0"
    '''(experimental) Schema version 1.0 for the component document.

    :stability: experimental
    '''


class ComponentStepIfCondition(
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentStepIfCondition",
):
    '''(experimental) Represents an ``if`` condition in the component document.

    :stability: experimental
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
        
        # if_object: Any
        
        component_step_if_condition = imagebuilder_alpha.ComponentStepIfCondition.from_object({
            "if_object_key": if_object
        })
    '''

    def __init__(self, if_condition: typing.Any) -> None:
        '''
        :param if_condition: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28e9b0814cd916ca01f8a7cf48021bfcd01d4c17be3ae2253fe86dd86f93d671)
            check_type(argname="argument if_condition", value=if_condition, expected_type=type_hints["if_condition"])
        jsii.create(self.__class__, self, [if_condition])

    @jsii.member(jsii_name="fromObject")
    @builtins.classmethod
    def from_object(
        cls,
        if_object: typing.Mapping[builtins.str, typing.Any],
    ) -> "ComponentStepIfCondition":
        '''(experimental) Creates the ``if`` value from an object, for the component step.

        :param if_object: The object containing the ``if`` condition.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd7bb86c499fa1670bd8e78f1bd8542abc56e983e69f40e47d32019e6656ffcc)
            check_type(argname="argument if_object", value=if_object, expected_type=type_hints["if_object"])
        return typing.cast("ComponentStepIfCondition", jsii.sinvoke(cls, "fromObject", [if_object]))

    @builtins.property
    @jsii.member(jsii_name="ifCondition")
    def if_condition(self) -> typing.Any:
        '''(experimental) The rendered input value.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "ifCondition"))


class ComponentStepInputs(
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ComponentStepInputs",
):
    '''(experimental) Represents the inputs for a step in the component document.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        phase = imagebuilder.ComponentDocumentPhase(
            name=imagebuilder.ComponentPhaseName.BUILD,
            steps=[imagebuilder.ComponentDocumentStep(
                name="configure-app",
                action=imagebuilder.ComponentAction.CREATE_FILE,
                inputs=imagebuilder.ComponentStepInputs.from_object({
                    "path": "/etc/myapp/config.json",
                    "content": "{\"env\": \"production\"}"
                })
            )
            ]
        )
    '''

    def __init__(self, input: typing.Any) -> None:
        '''
        :param input: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e53ae7d6d8c31ee6012880e97dd97ea37ce68d0a35e0216830ea8ab676a9ec3)
            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
        jsii.create(self.__class__, self, [input])

    @jsii.member(jsii_name="fromList")
    @builtins.classmethod
    def from_list(
        cls,
        inputs_object_list: typing.Sequence[typing.Mapping[builtins.str, typing.Any]],
    ) -> "ComponentStepInputs":
        '''(experimental) Creates the input value from a list of input objects, for the component step.

        :param inputs_object_list: The list of objects containing the input values.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79e97a2950e23ff264bda320a66d7ece7c77f491b953c2d2b71cb4ece4c553e4)
            check_type(argname="argument inputs_object_list", value=inputs_object_list, expected_type=type_hints["inputs_object_list"])
        return typing.cast("ComponentStepInputs", jsii.sinvoke(cls, "fromList", [inputs_object_list]))

    @jsii.member(jsii_name="fromObject")
    @builtins.classmethod
    def from_object(
        cls,
        inputs_object: typing.Mapping[builtins.str, typing.Any],
    ) -> "ComponentStepInputs":
        '''(experimental) Creates the input value from an object, for the component step.

        :param inputs_object: The object containing the input values.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61535270ffc68df1496f99af681d722e10151c09b0576885b939d7919cfb56b2)
            check_type(argname="argument inputs_object", value=inputs_object, expected_type=type_hints["inputs_object"])
        return typing.cast("ComponentStepInputs", jsii.sinvoke(cls, "fromObject", [inputs_object]))

    @builtins.property
    @jsii.member(jsii_name="inputs")
    def inputs(self) -> typing.Any:
        '''(experimental) The rendered input value.

        :stability: experimental
        '''
        return typing.cast(typing.Any, jsii.get(self, "inputs"))


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.ContainerDistribution",
    jsii_struct_bases=[],
    name_mapping={
        "container_repository": "containerRepository",
        "container_description": "containerDescription",
        "container_tags": "containerTags",
        "region": "region",
    },
)
class ContainerDistribution:
    def __init__(
        self,
        *,
        container_repository: "Repository",
        container_description: typing.Optional[builtins.str] = None,
        container_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The regional distribution settings to use for a container build.

        :param container_repository: (experimental) The destination repository to distribute the output container to. Default: The target repository in the container recipe is used
        :param container_description: (experimental) The description of the container image. Default: None
        :param container_tags: (experimental) The additional tags to apply to the distributed container images. Default: None
        :param region: (experimental) The target region to distribute containers to. Default: The current region is used

        :stability: experimental
        :exampleMetadata: infused

        Example::

            ecr_repository = ecr.Repository.from_repository_name(self, "ECRRepository", "my-repo")
            container_repository = imagebuilder.Repository.from_ecr(ecr_repository)
            container_distribution_configuration = imagebuilder.DistributionConfiguration(self, "ContainerDistributionConfiguration")
            
            container_distribution_configuration.add_container_distributions(
                container_repository=container_repository,
                container_description="Test container image",
                container_tags=["latest", "latest-1.0"]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e915667467bed957a52d2238405ebf79ca421c029bc891bb818483871e32a658)
            check_type(argname="argument container_repository", value=container_repository, expected_type=type_hints["container_repository"])
            check_type(argname="argument container_description", value=container_description, expected_type=type_hints["container_description"])
            check_type(argname="argument container_tags", value=container_tags, expected_type=type_hints["container_tags"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "container_repository": container_repository,
        }
        if container_description is not None:
            self._values["container_description"] = container_description
        if container_tags is not None:
            self._values["container_tags"] = container_tags
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def container_repository(self) -> "Repository":
        '''(experimental) The destination repository to distribute the output container to.

        :default: The target repository in the container recipe is used

        :stability: experimental
        '''
        result = self._values.get("container_repository")
        assert result is not None, "Required property 'container_repository' is missing"
        return typing.cast("Repository", result)

    @builtins.property
    def container_description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The description of the container image.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("container_description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def container_tags(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) The additional tags to apply to the distributed container images.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("container_tags")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''(experimental) The target region to distribute containers to.

        :default: The current region is used

        :stability: experimental
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ContainerDistribution(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.DistributionConfigurationProps",
    jsii_struct_bases=[],
    name_mapping={
        "ami_distributions": "amiDistributions",
        "container_distributions": "containerDistributions",
        "description": "description",
        "distribution_configuration_name": "distributionConfigurationName",
        "tags": "tags",
    },
)
class DistributionConfigurationProps:
    def __init__(
        self,
        *,
        ami_distributions: typing.Optional[typing.Sequence[typing.Union[AmiDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
        container_distributions: typing.Optional[typing.Sequence[typing.Union[ContainerDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
        description: typing.Optional[builtins.str] = None,
        distribution_configuration_name: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ) -> None:
        '''(experimental) Properties for creating a Distribution Configuration resource.

        :param ami_distributions: (experimental) The list of target regions and associated AMI distribution settings where the built AMI will be distributed. AMI distributions may also be added with the ``addAmiDistributions`` method. Default: None if container distributions are provided. Otherwise, at least one AMI or container distribution must be provided
        :param container_distributions: (experimental) The list of target regions and associated container distribution settings where the built container will be distributed. Container distributions may also be added with the ``addContainerDistributions`` method. Default: None if AMI distributions are provided. Otherwise, at least one AMI or container distribution must be provided
        :param description: (experimental) The description of the distribution configuration. Default: None
        :param distribution_configuration_name: (experimental) The name of the distribution configuration. Default: A name is generated
        :param tags: (experimental) The tags to apply to the distribution configuration. Default: None

        :stability: experimental
        :exampleMetadata: infused

        Example::

            distribution_configuration = imagebuilder.DistributionConfiguration(self, "DistributionConfiguration",
                distribution_configuration_name="test-distribution-configuration",
                description="A Distribution Configuration",
                ami_distributions=[imagebuilder.AmiDistribution(
                    # Distribute AMI to us-east-2 and publish the AMI ID to an SSM parameter
                    region="us-east-2",
                    ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                        parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossRegionParameter",
                            parameter_name="/imagebuilder/ami",
                            force_dynamic_reference=True
                        )
                    )
                    ]
                )
                ]
            )
            
            # For AMI-based image builds - add an AMI distribution in the current region
            distribution_configuration.add_ami_distributions(
                ami_name="imagebuilder-{{ imagebuilder:buildDate }}",
                ami_description="Build AMI",
                ami_kms_key=kms.Key.from_lookup(self, "ComponentKey", alias_name="alias/distribution-encryption-key"),
                # Copy the AMI to different accounts
                ami_target_account_ids=["123456789012", "098765432109"],
                # Add launch permissions on the AMI
                ami_launch_permission=imagebuilder.AmiLaunchPermission(
                    organization_arns=[
                        self.format_arn(region="", service="organizations", resource="organization", resource_name="o-1234567abc")
                    ],
                    organizational_unit_arns=[
                        self.format_arn(
                            region="",
                            service="organizations",
                            resource="ou",
                            resource_name="o-1234567abc/ou-a123-b4567890"
                        )
                    ],
                    is_public_user_group=True,
                    account_ids=["234567890123"]
                ),
                # Attach tags to the AMI
                ami_tags={
                    "Environment": "production",
                    "Version": "{{ imagebuilder:buildVersion }}"
                },
                # Optional - publish the distributed AMI ID to an SSM parameter
                ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                    parameter=ssm.StringParameter.from_string_parameter_attributes(self, "Parameter",
                        parameter_name="/imagebuilder/ami",
                        force_dynamic_reference=True
                    )
                ), imagebuilder.SSMParameterConfigurations(
                    ami_account="098765432109",
                    data_type=ssm.ParameterDataType.TEXT,
                    parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossAccountParameter",
                        parameter_name="imagebuilder-prod-ami",
                        force_dynamic_reference=True
                    )
                )
                ],
                # Optional - create a new launch template version with the distributed AMI ID
                launch_templates=[imagebuilder.LaunchTemplateConfiguration(
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "LaunchTemplate",
                        launch_template_id="lt-1234"
                    ),
                    set_default_version=True
                ), imagebuilder.LaunchTemplateConfiguration(
                    account_id="123456789012",
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "CrossAccountLaunchTemplate",
                        launch_template_id="lt-5678"
                    ),
                    set_default_version=True
                )
                ],
                # Optional - enable Fast Launch on an imported launch template
                fast_launch_configurations=[imagebuilder.FastLaunchConfiguration(
                    enabled=True,
                    launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "FastLaunchLT",
                        launch_template_name="fast-launch-lt"
                    ),
                    max_parallel_launches=10,
                    target_snapshot_count=2
                )
                ],
                # Optional - license configurations to apply to the AMI
                license_configuration_arns=["arn:aws:license-manager:us-west-2:123456789012:license-configuration:lic-abcdefghijklmnopqrstuvwxyz"
                ]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00a08291003318bd50149ef24f2bb14662ca021351848559c22243f8c7a24a58)
            check_type(argname="argument ami_distributions", value=ami_distributions, expected_type=type_hints["ami_distributions"])
            check_type(argname="argument container_distributions", value=container_distributions, expected_type=type_hints["container_distributions"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument distribution_configuration_name", value=distribution_configuration_name, expected_type=type_hints["distribution_configuration_name"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if ami_distributions is not None:
            self._values["ami_distributions"] = ami_distributions
        if container_distributions is not None:
            self._values["container_distributions"] = container_distributions
        if description is not None:
            self._values["description"] = description
        if distribution_configuration_name is not None:
            self._values["distribution_configuration_name"] = distribution_configuration_name
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def ami_distributions(self) -> typing.Optional[typing.List[AmiDistribution]]:
        '''(experimental) The list of target regions and associated AMI distribution settings where the built AMI will be distributed.

        AMI
        distributions may also be added with the ``addAmiDistributions`` method.

        :default:

        None if container distributions are provided. Otherwise, at least one AMI or container distribution must
        be provided

        :stability: experimental
        '''
        result = self._values.get("ami_distributions")
        return typing.cast(typing.Optional[typing.List[AmiDistribution]], result)

    @builtins.property
    def container_distributions(
        self,
    ) -> typing.Optional[typing.List[ContainerDistribution]]:
        '''(experimental) The list of target regions and associated container distribution settings where the built container will be distributed.

        Container distributions may also be added with the ``addContainerDistributions`` method.

        :default:

        None if AMI distributions are provided. Otherwise, at least one AMI or container distribution must be
        provided

        :stability: experimental
        '''
        result = self._values.get("container_distributions")
        return typing.cast(typing.Optional[typing.List[ContainerDistribution]], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The description of the distribution configuration.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def distribution_configuration_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the distribution configuration.

        :default: A name is generated

        :stability: experimental
        '''
        result = self._values.get("distribution_configuration_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(experimental) The tags to apply to the distribution configuration.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DistributionConfigurationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.FastLaunchConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "enabled": "enabled",
        "launch_template": "launchTemplate",
        "max_parallel_launches": "maxParallelLaunches",
        "target_snapshot_count": "targetSnapshotCount",
    },
)
class FastLaunchConfiguration:
    def __init__(
        self,
        *,
        enabled: typing.Optional[builtins.bool] = None,
        launch_template: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate] = None,
        max_parallel_launches: typing.Optional[jsii.Number] = None,
        target_snapshot_count: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) The EC2 Fast Launch configuration to use for the Windows AMI.

        :param enabled: (experimental) Whether to enable fast launch for the AMI. Default: false
        :param launch_template: (experimental) The launch template that the fast-launch enabled Windows AMI uses when it launches Windows instances to create pre-provisioned snapshots. Default: None
        :param max_parallel_launches: (experimental) The maximum number of parallel instances that are launched for creating resources. Default: A maximum of 6 instances are launched in parallel
        :param target_snapshot_count: (experimental) The number of pre-provisioned snapshots to keep on hand for a fast-launch enabled Windows AMI. Default: 10 snapshots are kept pre-provisioned

        :stability: experimental
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
            from aws_cdk import aws_ec2 as ec2
            
            # launch_template: ec2.LaunchTemplate
            
            fast_launch_configuration = imagebuilder_alpha.FastLaunchConfiguration(
                enabled=False,
                launch_template=launch_template,
                max_parallel_launches=123,
                target_snapshot_count=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b90ae1e7cf235ef00d4a47bdf413ccd7ca19785b18e7f91a75464655f60195df)
            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            check_type(argname="argument launch_template", value=launch_template, expected_type=type_hints["launch_template"])
            check_type(argname="argument max_parallel_launches", value=max_parallel_launches, expected_type=type_hints["max_parallel_launches"])
            check_type(argname="argument target_snapshot_count", value=target_snapshot_count, expected_type=type_hints["target_snapshot_count"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if enabled is not None:
            self._values["enabled"] = enabled
        if launch_template is not None:
            self._values["launch_template"] = launch_template
        if max_parallel_launches is not None:
            self._values["max_parallel_launches"] = max_parallel_launches
        if target_snapshot_count is not None:
            self._values["target_snapshot_count"] = target_snapshot_count

    @builtins.property
    def enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to enable fast launch for the AMI.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def launch_template(
        self,
    ) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate]:
        '''(experimental) The launch template that the fast-launch enabled Windows AMI uses when it launches Windows instances to create pre-provisioned snapshots.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("launch_template")
        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate], result)

    @builtins.property
    def max_parallel_launches(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The maximum number of parallel instances that are launched for creating resources.

        :default: A maximum of 6 instances are launched in parallel

        :see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableFastLaunch.html
        :stability: experimental
        '''
        result = self._values.get("max_parallel_launches")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def target_snapshot_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The number of pre-provisioned snapshots to keep on hand for a fast-launch enabled Windows AMI.

        :default: 10 snapshots are kept pre-provisioned

        :see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableFastLaunch.html
        :stability: experimental
        '''
        result = self._values.get("target_snapshot_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FastLaunchConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.HttpTokens")
class HttpTokens(enum.Enum):
    '''(experimental) Indicates whether a signed token header is required for instance metadata retrieval requests.

    :see: https://docs.aws.amazon.com/imagebuilder/latest/APIReference/API_InstanceMetadataOptions.html#imagebuilder-Type-InstanceMetadataOptions-httpTokens
    :stability: experimental
    :exampleMetadata: infused

    Example::

        infrastructure_configuration = imagebuilder.InfrastructureConfiguration(self, "InfrastructureConfiguration",
            infrastructure_configuration_name="test-infrastructure-configuration",
            description="An Infrastructure Configuration",
            # Optional - instance types to use for build/test
            instance_types=[
                ec2.InstanceType.of(ec2.InstanceClass.STANDARD7_INTEL, ec2.InstanceSize.LARGE),
                ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.LARGE)
            ],
            # Optional - create an instance profile with necessary permissions
            instance_profile=iam.InstanceProfile(self, "InstanceProfile",
                instance_profile_name="test-instance-profile",
                role=iam.Role(self, "InstanceProfileRole",
                    assumed_by=iam.ServicePrincipal.from_static_service_principle_name("ec2.amazonaws.com"),
                    managed_policies=[
                        iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSSMManagedInstanceCore"),
                        iam.ManagedPolicy.from_aws_managed_policy_name("EC2InstanceProfileForImageBuilder")
                    ]
                )
            ),
            # Use VPC network configuration
            vpc=vpc,
            subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
            security_groups=[ec2.SecurityGroup.from_security_group_id(self, "SecurityGroup", vpc.vpc_default_security_group)],
            key_pair=ec2.KeyPair.from_key_pair_name(self, "KeyPair", "imagebuilder-instance-key-pair"),
            terminate_instance_on_failure=True,
            # Optional - IMDSv2 settings
            http_tokens=imagebuilder.HttpTokens.REQUIRED,
            http_put_response_hop_limit=1,
            # Optional - publish image completion messages to an SNS topic
            notification_topic=sns.Topic.from_topic_arn(self, "Topic",
                self.format_arn(service="sns", resource="image-builder-topic")),
            # Optional - log settings. Logging is enabled by default
            logging=imagebuilder.InfrastructureConfigurationLogging(
                s3_bucket=s3.Bucket.from_bucket_name(self, "LogBucket", f"imagebuilder-logging-{Aws.ACCOUNT_ID}"),
                s3_key_prefix="imagebuilder-logs"
            ),
            # Optional - host placement settings
            ec2_instance_availability_zone=Stack.of(self).availability_zones[0],
            ec2_instance_host_id=dedicated_host.attr_host_id,
            ec2_instance_tenancy=imagebuilder.Tenancy.HOST,
            resource_tags={
                "Environment": "production"
            }
        )
    '''

    OPTIONAL = "OPTIONAL"
    '''(experimental) Allows retrieval of instance metadata with or without a signed token header in the request.

    :stability: experimental
    '''
    REQUIRED = "REQUIRED"
    '''(experimental) Requires a signed token header in instance metadata retrieval requests.

    :stability: experimental
    '''


@jsii.interface(jsii_type="@aws-cdk/aws-imagebuilder-alpha.IComponent")
class IComponent(_aws_cdk_ceddda9d.IResource, typing_extensions.Protocol):
    '''(experimental) An EC2 Image Builder Component.

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="componentArn")
    def component_arn(self) -> builtins.str:
        '''(experimental) The ARN of the component.

        :stability: experimental
        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="componentName")
    def component_name(self) -> builtins.str:
        '''(experimental) The name of the component.

        :stability: experimental
        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="componentVersion")
    def component_version(self) -> builtins.str:
        '''(experimental) The version of the component.

        :stability: experimental
        :attribute: true
        '''
        ...

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the component.

        :param grantee: The principal.
        :param actions: The list of actions.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the component.

        :param grantee: The principal.

        :stability: experimental
        '''
        ...


class _IComponentProxy(
    jsii.proxy_for(_aws_cdk_ceddda9d.IResource), # type: ignore[misc]
):
    '''(experimental) An EC2 Image Builder Component.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@aws-cdk/aws-imagebuilder-alpha.IComponent"

    @builtins.property
    @jsii.member(jsii_name="componentArn")
    def component_arn(self) -> builtins.str:
        '''(experimental) The ARN of the component.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "componentArn"))

    @builtins.property
    @jsii.member(jsii_name="componentName")
    def component_name(self) -> builtins.str:
        '''(experimental) The name of the component.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "componentName"))

    @builtins.property
    @jsii.member(jsii_name="componentVersion")
    def component_version(self) -> builtins.str:
        '''(experimental) The version of the component.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "componentVersion"))

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the component.

        :param grantee: The principal.
        :param actions: The list of actions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c05d6ee1a3eb8c5f9b0d715b586bd51b2a253ebbcc8dae51c78ae2c159bf057)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument actions", value=actions, expected_type=typing.Tuple[type_hints["actions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grant", [grantee, *actions]))

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the component.

        :param grantee: The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__841448c6baa993d7b4b3033a5490d19f411b8aebe362b78bd7e0490c73bd22d1)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [grantee]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IComponent).__jsii_proxy_class__ = lambda : _IComponentProxy


@jsii.interface(jsii_type="@aws-cdk/aws-imagebuilder-alpha.IDistributionConfiguration")
class IDistributionConfiguration(
    _aws_cdk_ceddda9d.IResource,
    typing_extensions.Protocol,
):
    '''(experimental) An EC2 Image Builder Distribution Configuration.

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="distributionConfigurationArn")
    def distribution_configuration_arn(self) -> builtins.str:
        '''(experimental) The ARN of the distribution configuration.

        :stability: experimental
        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="distributionConfigurationName")
    def distribution_configuration_name(self) -> builtins.str:
        '''(experimental) The name of the distribution configuration.

        :stability: experimental
        :attribute: true
        '''
        ...

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the distribution configuration.

        :param grantee: The principal.
        :param actions: The list of actions.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the distribution configuration.

        :param grantee: The principal.

        :stability: experimental
        '''
        ...


class _IDistributionConfigurationProxy(
    jsii.proxy_for(_aws_cdk_ceddda9d.IResource), # type: ignore[misc]
):
    '''(experimental) An EC2 Image Builder Distribution Configuration.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@aws-cdk/aws-imagebuilder-alpha.IDistributionConfiguration"

    @builtins.property
    @jsii.member(jsii_name="distributionConfigurationArn")
    def distribution_configuration_arn(self) -> builtins.str:
        '''(experimental) The ARN of the distribution configuration.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "distributionConfigurationArn"))

    @builtins.property
    @jsii.member(jsii_name="distributionConfigurationName")
    def distribution_configuration_name(self) -> builtins.str:
        '''(experimental) The name of the distribution configuration.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "distributionConfigurationName"))

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the distribution configuration.

        :param grantee: The principal.
        :param actions: The list of actions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0a9dae8c4b2356a5fed2efe8df76a59819e04e2a8562b9fe922537ca4b6313be)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument actions", value=actions, expected_type=typing.Tuple[type_hints["actions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grant", [grantee, *actions]))

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the distribution configuration.

        :param grantee: The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e644849da79fab144eff75407555da79d5543225778e3d852909fa3b1a1d2933)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [grantee]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IDistributionConfiguration).__jsii_proxy_class__ = lambda : _IDistributionConfigurationProxy


@jsii.interface(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.IInfrastructureConfiguration"
)
class IInfrastructureConfiguration(
    _aws_cdk_ceddda9d.IResource,
    typing_extensions.Protocol,
):
    '''(experimental) An EC2 Image Builder Infrastructure Configuration.

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="infrastructureConfigurationArn")
    def infrastructure_configuration_arn(self) -> builtins.str:
        '''(experimental) The ARN of the infrastructure configuration.

        :stability: experimental
        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="infrastructureConfigurationName")
    def infrastructure_configuration_name(self) -> builtins.str:
        '''(experimental) The name of the infrastructure configuration.

        :stability: experimental
        :attribute: true
        '''
        ...

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the infrastructure configuration.

        :param grantee: - The principal.
        :param actions: - The list of actions.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the infrastructure configuration.

        :param grantee: - The principal.

        :stability: experimental
        '''
        ...


class _IInfrastructureConfigurationProxy(
    jsii.proxy_for(_aws_cdk_ceddda9d.IResource), # type: ignore[misc]
):
    '''(experimental) An EC2 Image Builder Infrastructure Configuration.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@aws-cdk/aws-imagebuilder-alpha.IInfrastructureConfiguration"

    @builtins.property
    @jsii.member(jsii_name="infrastructureConfigurationArn")
    def infrastructure_configuration_arn(self) -> builtins.str:
        '''(experimental) The ARN of the infrastructure configuration.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "infrastructureConfigurationArn"))

    @builtins.property
    @jsii.member(jsii_name="infrastructureConfigurationName")
    def infrastructure_configuration_name(self) -> builtins.str:
        '''(experimental) The name of the infrastructure configuration.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "infrastructureConfigurationName"))

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the infrastructure configuration.

        :param grantee: - The principal.
        :param actions: - The list of actions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8f4ed7436405bcfb3a075aa5c93725806206943d8dbaa96c5cef8dd4d46cae37)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument actions", value=actions, expected_type=typing.Tuple[type_hints["actions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grant", [grantee, *actions]))

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the infrastructure configuration.

        :param grantee: - The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2582830fbd4fc0772d12414b5d2346ecedd7b1bb8582db47fa079012ef22197)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [grantee]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IInfrastructureConfiguration).__jsii_proxy_class__ = lambda : _IInfrastructureConfigurationProxy


@jsii.implements(IInfrastructureConfiguration)
class InfrastructureConfiguration(
    _aws_cdk_ceddda9d.Resource,
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.InfrastructureConfiguration",
):
    '''(experimental) Represents an EC2 Image Builder Infrastructure Configuration.

    :see: https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-infra-config.html
    :stability: experimental
    :exampleMetadata: infused

    Example::

        infrastructure_configuration = imagebuilder.InfrastructureConfiguration(self, "InfrastructureConfiguration",
            infrastructure_configuration_name="test-infrastructure-configuration",
            description="An Infrastructure Configuration",
            # Optional - instance types to use for build/test
            instance_types=[
                ec2.InstanceType.of(ec2.InstanceClass.STANDARD7_INTEL, ec2.InstanceSize.LARGE),
                ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.LARGE)
            ],
            # Optional - create an instance profile with necessary permissions
            instance_profile=iam.InstanceProfile(self, "InstanceProfile",
                instance_profile_name="test-instance-profile",
                role=iam.Role(self, "InstanceProfileRole",
                    assumed_by=iam.ServicePrincipal.from_static_service_principle_name("ec2.amazonaws.com"),
                    managed_policies=[
                        iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSSMManagedInstanceCore"),
                        iam.ManagedPolicy.from_aws_managed_policy_name("EC2InstanceProfileForImageBuilder")
                    ]
                )
            ),
            # Use VPC network configuration
            vpc=vpc,
            subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
            security_groups=[ec2.SecurityGroup.from_security_group_id(self, "SecurityGroup", vpc.vpc_default_security_group)],
            key_pair=ec2.KeyPair.from_key_pair_name(self, "KeyPair", "imagebuilder-instance-key-pair"),
            terminate_instance_on_failure=True,
            # Optional - IMDSv2 settings
            http_tokens=imagebuilder.HttpTokens.REQUIRED,
            http_put_response_hop_limit=1,
            # Optional - publish image completion messages to an SNS topic
            notification_topic=sns.Topic.from_topic_arn(self, "Topic",
                self.format_arn(service="sns", resource="image-builder-topic")),
            # Optional - log settings. Logging is enabled by default
            logging=imagebuilder.InfrastructureConfigurationLogging(
                s3_bucket=s3.Bucket.from_bucket_name(self, "LogBucket", f"imagebuilder-logging-{Aws.ACCOUNT_ID}"),
                s3_key_prefix="imagebuilder-logs"
            ),
            # Optional - host placement settings
            ec2_instance_availability_zone=Stack.of(self).availability_zones[0],
            ec2_instance_host_id=dedicated_host.attr_host_id,
            ec2_instance_tenancy=imagebuilder.Tenancy.HOST,
            resource_tags={
                "Environment": "production"
            }
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        ec2_instance_availability_zone: typing.Optional[builtins.str] = None,
        ec2_instance_host_id: typing.Optional[builtins.str] = None,
        ec2_instance_host_resource_group_arn: typing.Optional[builtins.str] = None,
        ec2_instance_tenancy: typing.Optional["Tenancy"] = None,
        http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
        http_tokens: typing.Optional[HttpTokens] = None,
        infrastructure_configuration_name: typing.Optional[builtins.str] = None,
        instance_profile: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IInstanceProfile] = None,
        instance_types: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.InstanceType]] = None,
        key_pair: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IKeyPair] = None,
        logging: typing.Optional[typing.Union["InfrastructureConfigurationLogging", typing.Dict[builtins.str, typing.Any]]] = None,
        notification_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
        resource_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
        security_groups: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]] = None,
        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        terminate_instance_on_failure: typing.Optional[builtins.bool] = None,
        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param description: (experimental) The description of the infrastructure configuration. Default: None
        :param ec2_instance_availability_zone: (experimental) The availability zone to place Image Builder build and test EC2 instances. Default: EC2 will select a random zone
        :param ec2_instance_host_id: (experimental) The ID of the Dedicated Host on which build and test instances run. This only applies if the instance tenancy is ``host``. This cannot be used with the ``ec2InstanceHostResourceGroupArn`` parameter. Default: None
        :param ec2_instance_host_resource_group_arn: (experimental) The ARN of the host resource group on which build and test instances run. This only applies if the instance tenancy is ``host``. This cannot be used with the ``ec2InstanceHostId`` parameter. Default: None
        :param ec2_instance_tenancy: (experimental) The tenancy of the instance. Dedicated tenancy runs instances on single-tenant hardware, while host tenancy runs instances on a dedicated host. Shared tenancy is used by default. Default: Tenancy.DEFAULT
        :param http_put_response_hop_limit: (experimental) The maximum number of hops that an instance metadata request can traverse to reach its destination. By default, this is set to 2. Default: 2
        :param http_tokens: (experimental) Indicates whether a signed token header is required for instance metadata retrieval requests. By default, this is set to ``required`` to require IMDSv2 on build and test EC2 instances. Default: HttpTokens.REQUIRED
        :param infrastructure_configuration_name: (experimental) The name of the infrastructure configuration. This name must be normalized by transforming all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens. Default: A name is generated
        :param instance_profile: (experimental) The instance profile to associate with the instance used to customize the AMI. By default, an instance profile and role will be created with minimal permissions needed to build the image, attached to the EC2 instance. If an S3 logging bucket and key prefix is provided, an IAM inline policy will be attached to the instance profile's role, allowing s3:PutObject permissions on the bucket. Default: An instance profile will be generated
        :param instance_types: (experimental) The instance types to launch build and test EC2 instances with. Default: Image Builder will choose from a default set of instance types compatible with the AMI
        :param key_pair: (experimental) The key pair used to connect to the build and test EC2 instances. The key pair can be used to log into the build or test instances for troubleshooting any failures. Default: None
        :param logging: (experimental) The log settings for detailed build logging. Default: None
        :param notification_topic: (experimental) The SNS topic on which notifications are sent when an image build completes. Default: No notifications are sent
        :param resource_tags: (experimental) The additional tags to assign to the Amazon EC2 instance that Image Builder launches during the build process. Default: None
        :param role: (experimental) An IAM role to associate with the instance profile used by Image Builder. The role must be assumable by the service principal ``ec2.amazonaws.com``: Note: You can provide an instanceProfile or a role, but not both. Default: A role will automatically be created, it can be accessed via the ``role`` property
        :param security_groups: (experimental) The security groups to associate with the instance used to customize the AMI. Default: The default security group for the VPC will be used
        :param subnet_selection: (experimental) Select which subnet to place the instance used to customize the AMI. The first subnet that is selected will be used. You must specify the VPC to customize the subnet selection. Default: The first subnet selected from the provided VPC will be used
        :param tags: (experimental) The tags to apply to the infrastructure configuration. Default: None
        :param terminate_instance_on_failure: (experimental) Whether to terminate the EC2 instance when the build or test workflow fails. Default: true
        :param vpc: (experimental) The VPC to place the instance used to customize the AMI. Default: The default VPC will be used

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f8672dd2c6991d2ba23136620a37140cb449f0b7606cfe5538649d44bc009387)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = InfrastructureConfigurationProps(
            description=description,
            ec2_instance_availability_zone=ec2_instance_availability_zone,
            ec2_instance_host_id=ec2_instance_host_id,
            ec2_instance_host_resource_group_arn=ec2_instance_host_resource_group_arn,
            ec2_instance_tenancy=ec2_instance_tenancy,
            http_put_response_hop_limit=http_put_response_hop_limit,
            http_tokens=http_tokens,
            infrastructure_configuration_name=infrastructure_configuration_name,
            instance_profile=instance_profile,
            instance_types=instance_types,
            key_pair=key_pair,
            logging=logging,
            notification_topic=notification_topic,
            resource_tags=resource_tags,
            role=role,
            security_groups=security_groups,
            subnet_selection=subnet_selection,
            tags=tags,
            terminate_instance_on_failure=terminate_instance_on_failure,
            vpc=vpc,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromInfrastructureConfigurationArn")
    @builtins.classmethod
    def from_infrastructure_configuration_arn(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        infrastructure_configuration_arn: builtins.str,
    ) -> IInfrastructureConfiguration:
        '''(experimental) Import an existing infrastructure configuration given its ARN.

        :param scope: -
        :param id: -
        :param infrastructure_configuration_arn: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__35015fe2e49bc142df9482904b92351bbc9b41c560cac1ac06713b2b564cd982)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument infrastructure_configuration_arn", value=infrastructure_configuration_arn, expected_type=type_hints["infrastructure_configuration_arn"])
        return typing.cast(IInfrastructureConfiguration, jsii.sinvoke(cls, "fromInfrastructureConfigurationArn", [scope, id, infrastructure_configuration_arn]))

    @jsii.member(jsii_name="fromInfrastructureConfigurationName")
    @builtins.classmethod
    def from_infrastructure_configuration_name(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        infrastructure_configuration_name: builtins.str,
    ) -> IInfrastructureConfiguration:
        '''(experimental) Import an existing infrastructure configuration given its name.

        The provided name must be normalized by converting
        all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.

        :param scope: -
        :param id: -
        :param infrastructure_configuration_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d30c941bd6f0f1b07145f10c999bbeef38a9fbbc483fdfb4e54de8301a42bd6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument infrastructure_configuration_name", value=infrastructure_configuration_name, expected_type=type_hints["infrastructure_configuration_name"])
        return typing.cast(IInfrastructureConfiguration, jsii.sinvoke(cls, "fromInfrastructureConfigurationName", [scope, id, infrastructure_configuration_name]))

    @jsii.member(jsii_name="isInfrastructureConfiguration")
    @builtins.classmethod
    def is_infrastructure_configuration(cls, x: typing.Any) -> builtins.bool:
        '''(experimental) Return whether the given object is an InfrastructureConfiguration.

        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__653ebae43bf6b6e095ea87727d122e7cab0c8786387877992a5a7e642a846e02)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isInfrastructureConfiguration", [x]))

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the infrastructure configuration.

        :param grantee: - The principal.
        :param actions: - The list of actions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d73bd89218669ef1c777360509401b7db5901968dd024b757f3c75f85ccd1228)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument actions", value=actions, expected_type=typing.Tuple[type_hints["actions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grant", [grantee, *actions]))

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the infrastructure configuration.

        :param grantee: - The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61c74f957e8c879932590c0d74b45224a68ab6d8eca577948a171e837ccc4cda)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [grantee]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
        '''(experimental) Uniquely identifies this class.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))

    @builtins.property
    @jsii.member(jsii_name="infrastructureConfigurationArn")
    def infrastructure_configuration_arn(self) -> builtins.str:
        '''(experimental) The ARN of the infrastructure configuration.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "infrastructureConfigurationArn"))

    @builtins.property
    @jsii.member(jsii_name="infrastructureConfigurationName")
    def infrastructure_configuration_name(self) -> builtins.str:
        '''(experimental) The name of the infrastructure configuration.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "infrastructureConfigurationName"))

    @builtins.property
    @jsii.member(jsii_name="instanceProfile")
    def instance_profile(self) -> _aws_cdk_aws_iam_ceddda9d.IInstanceProfile:
        '''(experimental) The EC2 instance profile to use for the build.

        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.IInstanceProfile, jsii.get(self, "instanceProfile"))

    @builtins.property
    @jsii.member(jsii_name="logBucket")
    def log_bucket(self) -> typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket]:
        '''(experimental) The bucket used to upload image build logs.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket], jsii.get(self, "logBucket"))

    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole]:
        '''(experimental) The role associated with the EC2 instance profile used for the build.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole], jsii.get(self, "role"))


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.InfrastructureConfigurationLogging",
    jsii_struct_bases=[],
    name_mapping={"s3_bucket": "s3Bucket", "s3_key_prefix": "s3KeyPrefix"},
)
class InfrastructureConfigurationLogging:
    def __init__(
        self,
        *,
        s3_bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        s3_key_prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) The log settings for detailed build logging.

        :param s3_bucket: (experimental) The S3 logging bucket to use for detailed build logging.
        :param s3_key_prefix: (experimental) The S3 logging prefix to use for detailed build logging. Default: No prefix

        :stability: experimental
        :exampleMetadata: infused

        Example::

            infrastructure_configuration = imagebuilder.InfrastructureConfiguration(self, "InfrastructureConfiguration",
                infrastructure_configuration_name="test-infrastructure-configuration",
                description="An Infrastructure Configuration",
                # Optional - instance types to use for build/test
                instance_types=[
                    ec2.InstanceType.of(ec2.InstanceClass.STANDARD7_INTEL, ec2.InstanceSize.LARGE),
                    ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.LARGE)
                ],
                # Optional - create an instance profile with necessary permissions
                instance_profile=iam.InstanceProfile(self, "InstanceProfile",
                    instance_profile_name="test-instance-profile",
                    role=iam.Role(self, "InstanceProfileRole",
                        assumed_by=iam.ServicePrincipal.from_static_service_principle_name("ec2.amazonaws.com"),
                        managed_policies=[
                            iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSSMManagedInstanceCore"),
                            iam.ManagedPolicy.from_aws_managed_policy_name("EC2InstanceProfileForImageBuilder")
                        ]
                    )
                ),
                # Use VPC network configuration
                vpc=vpc,
                subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
                security_groups=[ec2.SecurityGroup.from_security_group_id(self, "SecurityGroup", vpc.vpc_default_security_group)],
                key_pair=ec2.KeyPair.from_key_pair_name(self, "KeyPair", "imagebuilder-instance-key-pair"),
                terminate_instance_on_failure=True,
                # Optional - IMDSv2 settings
                http_tokens=imagebuilder.HttpTokens.REQUIRED,
                http_put_response_hop_limit=1,
                # Optional - publish image completion messages to an SNS topic
                notification_topic=sns.Topic.from_topic_arn(self, "Topic",
                    self.format_arn(service="sns", resource="image-builder-topic")),
                # Optional - log settings. Logging is enabled by default
                logging=imagebuilder.InfrastructureConfigurationLogging(
                    s3_bucket=s3.Bucket.from_bucket_name(self, "LogBucket", f"imagebuilder-logging-{Aws.ACCOUNT_ID}"),
                    s3_key_prefix="imagebuilder-logs"
                ),
                # Optional - host placement settings
                ec2_instance_availability_zone=Stack.of(self).availability_zones[0],
                ec2_instance_host_id=dedicated_host.attr_host_id,
                ec2_instance_tenancy=imagebuilder.Tenancy.HOST,
                resource_tags={
                    "Environment": "production"
                }
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__74cffe7aa25819eaef361f450e04e7112a9f46a9d0138a9696f9723b55a1d31d)
            check_type(argname="argument s3_bucket", value=s3_bucket, expected_type=type_hints["s3_bucket"])
            check_type(argname="argument s3_key_prefix", value=s3_key_prefix, expected_type=type_hints["s3_key_prefix"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "s3_bucket": s3_bucket,
        }
        if s3_key_prefix is not None:
            self._values["s3_key_prefix"] = s3_key_prefix

    @builtins.property
    def s3_bucket(self) -> _aws_cdk_aws_s3_ceddda9d.IBucket:
        '''(experimental) The S3 logging bucket to use for detailed build logging.

        :stability: experimental
        '''
        result = self._values.get("s3_bucket")
        assert result is not None, "Required property 's3_bucket' is missing"
        return typing.cast(_aws_cdk_aws_s3_ceddda9d.IBucket, result)

    @builtins.property
    def s3_key_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) The S3 logging prefix to use for detailed build logging.

        :default: No prefix

        :stability: experimental
        '''
        result = self._values.get("s3_key_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InfrastructureConfigurationLogging(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.InfrastructureConfigurationProps",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "ec2_instance_availability_zone": "ec2InstanceAvailabilityZone",
        "ec2_instance_host_id": "ec2InstanceHostId",
        "ec2_instance_host_resource_group_arn": "ec2InstanceHostResourceGroupArn",
        "ec2_instance_tenancy": "ec2InstanceTenancy",
        "http_put_response_hop_limit": "httpPutResponseHopLimit",
        "http_tokens": "httpTokens",
        "infrastructure_configuration_name": "infrastructureConfigurationName",
        "instance_profile": "instanceProfile",
        "instance_types": "instanceTypes",
        "key_pair": "keyPair",
        "logging": "logging",
        "notification_topic": "notificationTopic",
        "resource_tags": "resourceTags",
        "role": "role",
        "security_groups": "securityGroups",
        "subnet_selection": "subnetSelection",
        "tags": "tags",
        "terminate_instance_on_failure": "terminateInstanceOnFailure",
        "vpc": "vpc",
    },
)
class InfrastructureConfigurationProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        ec2_instance_availability_zone: typing.Optional[builtins.str] = None,
        ec2_instance_host_id: typing.Optional[builtins.str] = None,
        ec2_instance_host_resource_group_arn: typing.Optional[builtins.str] = None,
        ec2_instance_tenancy: typing.Optional["Tenancy"] = None,
        http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
        http_tokens: typing.Optional[HttpTokens] = None,
        infrastructure_configuration_name: typing.Optional[builtins.str] = None,
        instance_profile: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IInstanceProfile] = None,
        instance_types: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.InstanceType]] = None,
        key_pair: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IKeyPair] = None,
        logging: typing.Optional[typing.Union[InfrastructureConfigurationLogging, typing.Dict[builtins.str, typing.Any]]] = None,
        notification_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
        resource_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
        security_groups: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]] = None,
        subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        terminate_instance_on_failure: typing.Optional[builtins.bool] = None,
        vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
    ) -> None:
        '''(experimental) Properties for creating an Infrastructure Configuration resource.

        :param description: (experimental) The description of the infrastructure configuration. Default: None
        :param ec2_instance_availability_zone: (experimental) The availability zone to place Image Builder build and test EC2 instances. Default: EC2 will select a random zone
        :param ec2_instance_host_id: (experimental) The ID of the Dedicated Host on which build and test instances run. This only applies if the instance tenancy is ``host``. This cannot be used with the ``ec2InstanceHostResourceGroupArn`` parameter. Default: None
        :param ec2_instance_host_resource_group_arn: (experimental) The ARN of the host resource group on which build and test instances run. This only applies if the instance tenancy is ``host``. This cannot be used with the ``ec2InstanceHostId`` parameter. Default: None
        :param ec2_instance_tenancy: (experimental) The tenancy of the instance. Dedicated tenancy runs instances on single-tenant hardware, while host tenancy runs instances on a dedicated host. Shared tenancy is used by default. Default: Tenancy.DEFAULT
        :param http_put_response_hop_limit: (experimental) The maximum number of hops that an instance metadata request can traverse to reach its destination. By default, this is set to 2. Default: 2
        :param http_tokens: (experimental) Indicates whether a signed token header is required for instance metadata retrieval requests. By default, this is set to ``required`` to require IMDSv2 on build and test EC2 instances. Default: HttpTokens.REQUIRED
        :param infrastructure_configuration_name: (experimental) The name of the infrastructure configuration. This name must be normalized by transforming all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens. Default: A name is generated
        :param instance_profile: (experimental) The instance profile to associate with the instance used to customize the AMI. By default, an instance profile and role will be created with minimal permissions needed to build the image, attached to the EC2 instance. If an S3 logging bucket and key prefix is provided, an IAM inline policy will be attached to the instance profile's role, allowing s3:PutObject permissions on the bucket. Default: An instance profile will be generated
        :param instance_types: (experimental) The instance types to launch build and test EC2 instances with. Default: Image Builder will choose from a default set of instance types compatible with the AMI
        :param key_pair: (experimental) The key pair used to connect to the build and test EC2 instances. The key pair can be used to log into the build or test instances for troubleshooting any failures. Default: None
        :param logging: (experimental) The log settings for detailed build logging. Default: None
        :param notification_topic: (experimental) The SNS topic on which notifications are sent when an image build completes. Default: No notifications are sent
        :param resource_tags: (experimental) The additional tags to assign to the Amazon EC2 instance that Image Builder launches during the build process. Default: None
        :param role: (experimental) An IAM role to associate with the instance profile used by Image Builder. The role must be assumable by the service principal ``ec2.amazonaws.com``: Note: You can provide an instanceProfile or a role, but not both. Default: A role will automatically be created, it can be accessed via the ``role`` property
        :param security_groups: (experimental) The security groups to associate with the instance used to customize the AMI. Default: The default security group for the VPC will be used
        :param subnet_selection: (experimental) Select which subnet to place the instance used to customize the AMI. The first subnet that is selected will be used. You must specify the VPC to customize the subnet selection. Default: The first subnet selected from the provided VPC will be used
        :param tags: (experimental) The tags to apply to the infrastructure configuration. Default: None
        :param terminate_instance_on_failure: (experimental) Whether to terminate the EC2 instance when the build or test workflow fails. Default: true
        :param vpc: (experimental) The VPC to place the instance used to customize the AMI. Default: The default VPC will be used

        :stability: experimental
        :exampleMetadata: infused

        Example::

            infrastructure_configuration = imagebuilder.InfrastructureConfiguration(self, "InfrastructureConfiguration",
                infrastructure_configuration_name="test-infrastructure-configuration",
                description="An Infrastructure Configuration",
                # Optional - instance types to use for build/test
                instance_types=[
                    ec2.InstanceType.of(ec2.InstanceClass.STANDARD7_INTEL, ec2.InstanceSize.LARGE),
                    ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.LARGE)
                ],
                # Optional - create an instance profile with necessary permissions
                instance_profile=iam.InstanceProfile(self, "InstanceProfile",
                    instance_profile_name="test-instance-profile",
                    role=iam.Role(self, "InstanceProfileRole",
                        assumed_by=iam.ServicePrincipal.from_static_service_principle_name("ec2.amazonaws.com"),
                        managed_policies=[
                            iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSSMManagedInstanceCore"),
                            iam.ManagedPolicy.from_aws_managed_policy_name("EC2InstanceProfileForImageBuilder")
                        ]
                    )
                ),
                # Use VPC network configuration
                vpc=vpc,
                subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
                security_groups=[ec2.SecurityGroup.from_security_group_id(self, "SecurityGroup", vpc.vpc_default_security_group)],
                key_pair=ec2.KeyPair.from_key_pair_name(self, "KeyPair", "imagebuilder-instance-key-pair"),
                terminate_instance_on_failure=True,
                # Optional - IMDSv2 settings
                http_tokens=imagebuilder.HttpTokens.REQUIRED,
                http_put_response_hop_limit=1,
                # Optional - publish image completion messages to an SNS topic
                notification_topic=sns.Topic.from_topic_arn(self, "Topic",
                    self.format_arn(service="sns", resource="image-builder-topic")),
                # Optional - log settings. Logging is enabled by default
                logging=imagebuilder.InfrastructureConfigurationLogging(
                    s3_bucket=s3.Bucket.from_bucket_name(self, "LogBucket", f"imagebuilder-logging-{Aws.ACCOUNT_ID}"),
                    s3_key_prefix="imagebuilder-logs"
                ),
                # Optional - host placement settings
                ec2_instance_availability_zone=Stack.of(self).availability_zones[0],
                ec2_instance_host_id=dedicated_host.attr_host_id,
                ec2_instance_tenancy=imagebuilder.Tenancy.HOST,
                resource_tags={
                    "Environment": "production"
                }
            )
        '''
        if isinstance(logging, dict):
            logging = InfrastructureConfigurationLogging(**logging)
        if isinstance(subnet_selection, dict):
            subnet_selection = _aws_cdk_aws_ec2_ceddda9d.SubnetSelection(**subnet_selection)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__07545a4f62a3521f9640beafa4b4d7cc1fbe20fc1df54541287ed96ffe7f8e4e)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument ec2_instance_availability_zone", value=ec2_instance_availability_zone, expected_type=type_hints["ec2_instance_availability_zone"])
            check_type(argname="argument ec2_instance_host_id", value=ec2_instance_host_id, expected_type=type_hints["ec2_instance_host_id"])
            check_type(argname="argument ec2_instance_host_resource_group_arn", value=ec2_instance_host_resource_group_arn, expected_type=type_hints["ec2_instance_host_resource_group_arn"])
            check_type(argname="argument ec2_instance_tenancy", value=ec2_instance_tenancy, expected_type=type_hints["ec2_instance_tenancy"])
            check_type(argname="argument http_put_response_hop_limit", value=http_put_response_hop_limit, expected_type=type_hints["http_put_response_hop_limit"])
            check_type(argname="argument http_tokens", value=http_tokens, expected_type=type_hints["http_tokens"])
            check_type(argname="argument infrastructure_configuration_name", value=infrastructure_configuration_name, expected_type=type_hints["infrastructure_configuration_name"])
            check_type(argname="argument instance_profile", value=instance_profile, expected_type=type_hints["instance_profile"])
            check_type(argname="argument instance_types", value=instance_types, expected_type=type_hints["instance_types"])
            check_type(argname="argument key_pair", value=key_pair, expected_type=type_hints["key_pair"])
            check_type(argname="argument logging", value=logging, expected_type=type_hints["logging"])
            check_type(argname="argument notification_topic", value=notification_topic, expected_type=type_hints["notification_topic"])
            check_type(argname="argument resource_tags", value=resource_tags, expected_type=type_hints["resource_tags"])
            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
            check_type(argname="argument subnet_selection", value=subnet_selection, expected_type=type_hints["subnet_selection"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument terminate_instance_on_failure", value=terminate_instance_on_failure, expected_type=type_hints["terminate_instance_on_failure"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if ec2_instance_availability_zone is not None:
            self._values["ec2_instance_availability_zone"] = ec2_instance_availability_zone
        if ec2_instance_host_id is not None:
            self._values["ec2_instance_host_id"] = ec2_instance_host_id
        if ec2_instance_host_resource_group_arn is not None:
            self._values["ec2_instance_host_resource_group_arn"] = ec2_instance_host_resource_group_arn
        if ec2_instance_tenancy is not None:
            self._values["ec2_instance_tenancy"] = ec2_instance_tenancy
        if http_put_response_hop_limit is not None:
            self._values["http_put_response_hop_limit"] = http_put_response_hop_limit
        if http_tokens is not None:
            self._values["http_tokens"] = http_tokens
        if infrastructure_configuration_name is not None:
            self._values["infrastructure_configuration_name"] = infrastructure_configuration_name
        if instance_profile is not None:
            self._values["instance_profile"] = instance_profile
        if instance_types is not None:
            self._values["instance_types"] = instance_types
        if key_pair is not None:
            self._values["key_pair"] = key_pair
        if logging is not None:
            self._values["logging"] = logging
        if notification_topic is not None:
            self._values["notification_topic"] = notification_topic
        if resource_tags is not None:
            self._values["resource_tags"] = resource_tags
        if role is not None:
            self._values["role"] = role
        if security_groups is not None:
            self._values["security_groups"] = security_groups
        if subnet_selection is not None:
            self._values["subnet_selection"] = subnet_selection
        if tags is not None:
            self._values["tags"] = tags
        if terminate_instance_on_failure is not None:
            self._values["terminate_instance_on_failure"] = terminate_instance_on_failure
        if vpc is not None:
            self._values["vpc"] = vpc

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''(experimental) The description of the infrastructure configuration.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_instance_availability_zone(self) -> typing.Optional[builtins.str]:
        '''(experimental) The availability zone to place Image Builder build and test EC2 instances.

        :default: EC2 will select a random zone

        :stability: experimental
        '''
        result = self._values.get("ec2_instance_availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_instance_host_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) The ID of the Dedicated Host on which build and test instances run.

        This only applies if the instance tenancy is
        ``host``. This cannot be used with the ``ec2InstanceHostResourceGroupArn`` parameter.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ec2_instance_host_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_instance_host_resource_group_arn(self) -> typing.Optional[builtins.str]:
        '''(experimental) The ARN of the host resource group on which build and test instances run.

        This only applies if the instance tenancy
        is ``host``. This cannot be used with the ``ec2InstanceHostId`` parameter.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("ec2_instance_host_resource_group_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ec2_instance_tenancy(self) -> typing.Optional["Tenancy"]:
        '''(experimental) The tenancy of the instance.

        Dedicated tenancy runs instances on single-tenant hardware, while host tenancy runs
        instances on a dedicated host. Shared tenancy is used by default.

        :default: Tenancy.DEFAULT

        :stability: experimental
        '''
        result = self._values.get("ec2_instance_tenancy")
        return typing.cast(typing.Optional["Tenancy"], result)

    @builtins.property
    def http_put_response_hop_limit(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The maximum number of hops that an instance metadata request can traverse to reach its destination.

        By default,
        this is set to 2.

        :default: 2

        :stability: experimental
        '''
        result = self._values.get("http_put_response_hop_limit")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def http_tokens(self) -> typing.Optional[HttpTokens]:
        '''(experimental) Indicates whether a signed token header is required for instance metadata retrieval requests.

        By default, this is
        set to ``required`` to require IMDSv2 on build and test EC2 instances.

        :default: HttpTokens.REQUIRED

        :stability: experimental
        '''
        result = self._values.get("http_tokens")
        return typing.cast(typing.Optional[HttpTokens], result)

    @builtins.property
    def infrastructure_configuration_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the infrastructure configuration.

        This name must be normalized by transforming all alphabetical
        characters to lowercase, and replacing all spaces and underscores with hyphens.

        :default: A name is generated

        :stability: experimental
        '''
        result = self._values.get("infrastructure_configuration_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_profile(
        self,
    ) -> typing.Optional[_aws_cdk_aws_iam_ceddda9d.IInstanceProfile]:
        '''(experimental) The instance profile to associate with the instance used to customize the AMI.

        By default, an instance profile and role will be created with minimal permissions needed to build the image,
        attached to the EC2 instance.

        If an S3 logging bucket and key prefix is provided, an IAM inline policy will be attached to the instance profile's
        role, allowing s3:PutObject permissions on the bucket.

        :default: An instance profile will be generated

        :stability: experimental
        '''
        result = self._values.get("instance_profile")
        return typing.cast(typing.Optional[_aws_cdk_aws_iam_ceddda9d.IInstanceProfile], result)

    @builtins.property
    def instance_types(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_ec2_ceddda9d.InstanceType]]:
        '''(experimental) The instance types to launch build and test EC2 instances with.

        :default: Image Builder will choose from a default set of instance types compatible with the AMI

        :stability: experimental
        '''
        result = self._values.get("instance_types")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_ec2_ceddda9d.InstanceType]], result)

    @builtins.property
    def key_pair(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IKeyPair]:
        '''(experimental) The key pair used to connect to the build and test EC2 instances.

        The key pair can be used to log into the build
        or test instances for troubleshooting any failures.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("key_pair")
        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IKeyPair], result)

    @builtins.property
    def logging(self) -> typing.Optional[InfrastructureConfigurationLogging]:
        '''(experimental) The log settings for detailed build logging.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("logging")
        return typing.cast(typing.Optional[InfrastructureConfigurationLogging], result)

    @builtins.property
    def notification_topic(self) -> typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic]:
        '''(experimental) The SNS topic on which notifications are sent when an image build completes.

        :default: No notifications are sent

        :stability: experimental
        '''
        result = self._values.get("notification_topic")
        return typing.cast(typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic], result)

    @builtins.property
    def resource_tags(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(experimental) The additional tags to assign to the Amazon EC2 instance that Image Builder launches during the build process.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("resource_tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def role(self) -> typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole]:
        '''(experimental) An IAM role to associate with the instance profile used by Image Builder.

        The role must be assumable by the service principal ``ec2.amazonaws.com``:
        Note: You can provide an instanceProfile or a role, but not both.

        :default: A role will automatically be created, it can be accessed via the ``role`` property

        :stability: experimental

        Example::

            role = iam.Role(self, "MyRole",
                assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")
            )
        '''
        result = self._values.get("role")
        return typing.cast(typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole], result)

    @builtins.property
    def security_groups(
        self,
    ) -> typing.Optional[typing.List[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]]:
        '''(experimental) The security groups to associate with the instance used to customize the AMI.

        :default: The default security group for the VPC will be used

        :stability: experimental
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]], result)

    @builtins.property
    def subnet_selection(
        self,
    ) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection]:
        '''(experimental) Select which subnet to place the instance used to customize the AMI.

        The first subnet that is selected will be used.
        You must specify the VPC to customize the subnet selection.

        :default: The first subnet selected from the provided VPC will be used

        :stability: experimental
        '''
        result = self._values.get("subnet_selection")
        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''(experimental) The tags to apply to the infrastructure configuration.

        :default: None

        :stability: experimental
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def terminate_instance_on_failure(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to terminate the EC2 instance when the build or test workflow fails.

        :default: true

        :stability: experimental
        '''
        result = self._values.get("terminate_instance_on_failure")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def vpc(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc]:
        '''(experimental) The VPC to place the instance used to customize the AMI.

        :default: The default VPC will be used

        :stability: experimental
        '''
        result = self._values.get("vpc")
        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InfrastructureConfigurationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.LaunchTemplateConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "launch_template": "launchTemplate",
        "account_id": "accountId",
        "set_default_version": "setDefaultVersion",
    },
)
class LaunchTemplateConfiguration:
    def __init__(
        self,
        *,
        launch_template: _aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate,
        account_id: typing.Optional[builtins.str] = None,
        set_default_version: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) The launch template to apply the distributed AMI to.

        :param launch_template: (experimental) The launch template to apply the distributed AMI to. A new launch template version will be created for the provided launch template with the distributed AMI applied. *Note:* The launch template should expose a ``launchTemplateId``. Templates imported by name only are not supported.
        :param account_id: (experimental) The AWS account ID that owns the launch template. Default: The current account is used
        :param set_default_version: (experimental) Whether to set the new launch template version that is created as the default launch template version. After creation of the launch template version containing the distributed AMI, it will be automatically set as the default version for the launch template. Default: false

        :stability: experimental
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
            from aws_cdk import aws_ec2 as ec2
            
            # launch_template: ec2.LaunchTemplate
            
            launch_template_configuration = imagebuilder_alpha.LaunchTemplateConfiguration(
                launch_template=launch_template,
            
                # the properties below are optional
                account_id="accountId",
                set_default_version=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7488a156223bbf9e56775eef019a0bfc54d1cbe34be84e101b6775196600d51d)
            check_type(argname="argument launch_template", value=launch_template, expected_type=type_hints["launch_template"])
            check_type(argname="argument account_id", value=account_id, expected_type=type_hints["account_id"])
            check_type(argname="argument set_default_version", value=set_default_version, expected_type=type_hints["set_default_version"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "launch_template": launch_template,
        }
        if account_id is not None:
            self._values["account_id"] = account_id
        if set_default_version is not None:
            self._values["set_default_version"] = set_default_version

    @builtins.property
    def launch_template(self) -> _aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate:
        '''(experimental) The launch template to apply the distributed AMI to.

        A new launch template version will be created for the
        provided launch template with the distributed AMI applied.

        *Note:* The launch template should expose a ``launchTemplateId``. Templates
        imported by name only are not supported.

        :stability: experimental
        '''
        result = self._values.get("launch_template")
        assert result is not None, "Required property 'launch_template' is missing"
        return typing.cast(_aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate, result)

    @builtins.property
    def account_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) The AWS account ID that owns the launch template.

        :default: The current account is used

        :stability: experimental
        '''
        result = self._values.get("account_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def set_default_version(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to set the new launch template version that is created as the default launch template version.

        After
        creation of the launch template version containing the distributed AMI, it will be automatically set as the
        default version for the launch template.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("set_default_version")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LaunchTemplateConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class OSVersion(
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.OSVersion",
):
    '''(experimental) Represents an OS version for an EC2 Image Builder image.

    :stability: experimental
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
        
        o_sVersion = imagebuilder_alpha.OSVersion.AMAZON_LINUX
    '''

    def __init__(
        self,
        platform: "Platform",
        os_version: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param platform: -
        :param os_version: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f5e835db1a09fe43e2d622f4324c6ace2e9dbd991bf060bc80994a8c7f278814)
            check_type(argname="argument platform", value=platform, expected_type=type_hints["platform"])
            check_type(argname="argument os_version", value=os_version, expected_type=type_hints["os_version"])
        jsii.create(self.__class__, self, [platform, os_version])

    @jsii.member(jsii_name="custom")
    @builtins.classmethod
    def custom(
        cls,
        platform: "Platform",
        os_version: typing.Optional[builtins.str] = None,
    ) -> "OSVersion":
        '''(experimental) Constructs an OS version with a custom name.

        :param platform: The platform of the OS version.
        :param os_version: The custom OS version to use.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ff5a2c2e2f508c6ffd9d7b790056aed4fb62718c2288d6565e09783a7327d151)
            check_type(argname="argument platform", value=platform, expected_type=type_hints["platform"])
            check_type(argname="argument os_version", value=os_version, expected_type=type_hints["os_version"])
        return typing.cast("OSVersion", jsii.sinvoke(cls, "custom", [platform, os_version]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AMAZON_LINUX")
    def AMAZON_LINUX(cls) -> "OSVersion":
        '''(experimental) OS version for all Amazon Linux images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "AMAZON_LINUX"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AMAZON_LINUX_2")
    def AMAZON_LINUX_2(cls) -> "OSVersion":
        '''(experimental) OS version for Amazon Linux 2.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "AMAZON_LINUX_2"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AMAZON_LINUX_2023")
    def AMAZON_LINUX_2023(cls) -> "OSVersion":
        '''(experimental) OS version for Amazon Linux 2023.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "AMAZON_LINUX_2023"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LINUX")
    def LINUX(cls) -> "OSVersion":
        '''(experimental) OS version for all Linux images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "LINUX"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAC_OS")
    def MAC_OS(cls) -> "OSVersion":
        '''(experimental) OS version for all macOS images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "MAC_OS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAC_OS_14")
    def MAC_OS_14(cls) -> "OSVersion":
        '''(experimental) OS version for macOS 14.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "MAC_OS_14"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAC_OS_15")
    def MAC_OS_15(cls) -> "OSVersion":
        '''(experimental) OS version for macOS 15.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "MAC_OS_15"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REDHAT_ENTERPRISE_LINUX")
    def REDHAT_ENTERPRISE_LINUX(cls) -> "OSVersion":
        '''(experimental) OS version for all Red Hat Enterprise Linux images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "REDHAT_ENTERPRISE_LINUX"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REDHAT_ENTERPRISE_LINUX_10")
    def REDHAT_ENTERPRISE_LINUX_10(cls) -> "OSVersion":
        '''(experimental) OS version for Red Hat Enterprise Linux 10.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "REDHAT_ENTERPRISE_LINUX_10"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REDHAT_ENTERPRISE_LINUX_8")
    def REDHAT_ENTERPRISE_LINUX_8(cls) -> "OSVersion":
        '''(experimental) OS version for Red Hat Enterprise Linux 8.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "REDHAT_ENTERPRISE_LINUX_8"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REDHAT_ENTERPRISE_LINUX_9")
    def REDHAT_ENTERPRISE_LINUX_9(cls) -> "OSVersion":
        '''(experimental) OS version for Red Hat Enterprise Linux 9.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "REDHAT_ENTERPRISE_LINUX_9"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SLES")
    def SLES(cls) -> "OSVersion":
        '''(experimental) OS version for all SLES images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "SLES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SLES_15")
    def SLES_15(cls) -> "OSVersion":
        '''(experimental) OS version for SLES 15.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "SLES_15"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="UBUNTU")
    def UBUNTU(cls) -> "OSVersion":
        '''(experimental) OS version for all Ubuntu images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "UBUNTU"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="UBUNTU_22_04")
    def UBUNTU_22_04(cls) -> "OSVersion":
        '''(experimental) OS version for Ubuntu 22.04.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "UBUNTU_22_04"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="UBUNTU_24_04")
    def UBUNTU_24_04(cls) -> "OSVersion":
        '''(experimental) OS version for Ubuntu 24.04.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "UBUNTU_24_04"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WINDOWS")
    def WINDOWS(cls) -> "OSVersion":
        '''(experimental) OS version for all Windows images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "WINDOWS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WINDOWS_SERVER")
    def WINDOWS_SERVER(cls) -> "OSVersion":
        '''(experimental) OS version for all Windows server images.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "WINDOWS_SERVER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WINDOWS_SERVER_2016")
    def WINDOWS_SERVER_2016(cls) -> "OSVersion":
        '''(experimental) OS version for Windows Server 2016.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "WINDOWS_SERVER_2016"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WINDOWS_SERVER_2019")
    def WINDOWS_SERVER_2019(cls) -> "OSVersion":
        '''(experimental) OS version for Windows Server 2019.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "WINDOWS_SERVER_2019"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WINDOWS_SERVER_2022")
    def WINDOWS_SERVER_2022(cls) -> "OSVersion":
        '''(experimental) OS version for Windows Server 2022.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "WINDOWS_SERVER_2022"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WINDOWS_SERVER_2025")
    def WINDOWS_SERVER_2025(cls) -> "OSVersion":
        '''(experimental) OS version for Windows Server 2025.

        :stability: experimental
        '''
        return typing.cast("OSVersion", jsii.sget(cls, "WINDOWS_SERVER_2025"))

    @builtins.property
    @jsii.member(jsii_name="platform")
    def platform(self) -> "Platform":
        '''(experimental) The Platform of the OS version.

        :stability: experimental
        '''
        return typing.cast("Platform", jsii.get(self, "platform"))

    @builtins.property
    @jsii.member(jsii_name="osVersion")
    def os_version(self) -> typing.Optional[builtins.str]:
        '''(experimental) The OS version name.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "osVersion"))


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.Platform")
class Platform(enum.Enum):
    '''(experimental) Represents a platform for an EC2 Image Builder image.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        component = imagebuilder.Component(self, "MyComponent",
            platform=imagebuilder.Platform.LINUX,
            data=imagebuilder.ComponentData.from_json_object({
                "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
                "phases": [{
                    "name": imagebuilder.ComponentPhaseName.BUILD,
                    "steps": [{
                        "name": "install-app",
                        "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                        "inputs": {
                            "commands": ["echo \"Installing my application...\"", "yum update -y"]
                        }
                    }
                    ]
                }
                ]
            })
        )
    '''

    LINUX = "LINUX"
    '''(experimental) Platform for Linux.

    :stability: experimental
    '''
    WINDOWS = "WINDOWS"
    '''(experimental) Platform for Windows.

    :stability: experimental
    '''
    MAC_OS = "MAC_OS"
    '''(experimental) Platform for macOS.

    :stability: experimental
    '''


class Repository(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.Repository",
):
    '''(experimental) A container repository used to distribute container images in EC2 Image Builder.

    :stability: experimental
    :exampleMetadata: infused

    Example::

        ecr_repository = ecr.Repository.from_repository_name(self, "ECRRepository", "my-repo")
        image_builder_repository = imagebuilder.Repository.from_ecr(ecr_repository)
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="fromEcr")
    @builtins.classmethod
    def from_ecr(
        cls,
        repository: _aws_cdk_aws_ecr_ceddda9d.IRepository,
    ) -> "Repository":
        '''(experimental) The ECR repository to use as the target container repository.

        :param repository: The ECR repository to use.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bf80e8cbc35b94d36db54f92df03bee46b372adfb0f2a76712eaf0f716c17c3e)
            check_type(argname="argument repository", value=repository, expected_type=type_hints["repository"])
        return typing.cast("Repository", jsii.sinvoke(cls, "fromEcr", [repository]))

    @builtins.property
    @jsii.member(jsii_name="repositoryName")
    @abc.abstractmethod
    def repository_name(self) -> builtins.str:
        '''(experimental) The name of the container repository where the output container image is stored.

        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="service")
    @abc.abstractmethod
    def service(self) -> "RepositoryService":
        '''(experimental) The service in which the container repository is hosted.

        :stability: experimental
        '''
        ...


class _RepositoryProxy(Repository):
    @builtins.property
    @jsii.member(jsii_name="repositoryName")
    def repository_name(self) -> builtins.str:
        '''(experimental) The name of the container repository where the output container image is stored.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "repositoryName"))

    @builtins.property
    @jsii.member(jsii_name="service")
    def service(self) -> "RepositoryService":
        '''(experimental) The service in which the container repository is hosted.

        :stability: experimental
        '''
        return typing.cast("RepositoryService", jsii.get(self, "service"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, Repository).__jsii_proxy_class__ = lambda : _RepositoryProxy


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.RepositoryService")
class RepositoryService(enum.Enum):
    '''(experimental) The service in which a container should be registered.

    :stability: experimental
    '''

    ECR = "ECR"
    '''(experimental) Indicates the container should be registered in ECR.

    :stability: experimental
    '''


class S3ComponentData(
    ComponentData,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.S3ComponentData",
):
    '''(experimental) Helper class for S3-based component data references, containing additional permission grant methods on the S3 object.

    :stability: experimental
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
        import aws_cdk as cdk
        from aws_cdk import aws_iam as iam
        from aws_cdk.interfaces import aws_kms as interfaces_aws_kms
        
        # docker_image: cdk.DockerImage
        # grantable: iam.IGrantable
        # key_ref: interfaces_aws_kms.IKeyRef
        # local_bundling: cdk.ILocalBundling
        
        s3_component_data = imagebuilder_alpha.S3ComponentData.from_asset(self, "MyS3ComponentData", "path",
            asset_hash="assetHash",
            asset_hash_type=cdk.AssetHashType.SOURCE,
            bundling=cdk.BundlingOptions(
                image=docker_image,
        
                # the properties below are optional
                bundling_file_access=cdk.BundlingFileAccess.VOLUME_COPY,
                command=["command"],
                entrypoint=["entrypoint"],
                environment={
                    "environment_key": "environment"
                },
                local=local_bundling,
                network="network",
                output_type=cdk.BundlingOutput.ARCHIVED,
                platform="platform",
                security_opt="securityOpt",
                user="user",
                volumes=[cdk.DockerVolume(
                    container_path="containerPath",
                    host_path="hostPath",
        
                    # the properties below are optional
                    consistency=cdk.DockerVolumeConsistency.CONSISTENT
                )],
                volumes_from=["volumesFrom"],
                working_directory="workingDirectory"
            ),
            deploy_time=False,
            display_name="displayName",
            exclude=["exclude"],
            follow_symlinks=cdk.SymlinkFollowMode.NEVER,
            ignore_mode=cdk.IgnoreMode.GLOB,
            readers=[grantable],
            source_kMSKey=key_ref
        )
    '''

    def __init__(
        self,
        bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
        key: builtins.str,
    ) -> None:
        '''
        :param bucket: -
        :param key: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8cfdd61801a768cf18184f1eb0737a88d90c072ea930a509e6fe06fcff393d8)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        jsii.create(self.__class__, self, [bucket, key])

    @jsii.member(jsii_name="grantPut")
    def grant_put(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant put permissions to the given grantee for the component data in S3.

        :param grantee: The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cc38fb84d23f869830d4eb53138914295325097f770e7d5bd62c28c8cedaaa0c)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantPut", [grantee]))

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the component data in S3.

        :param grantee: The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__022e6141b2cc124364e4bd232e91e64e60212165c7aca9e98a54c50a7b0e1bb7)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [grantee]))

    @builtins.property
    @jsii.member(jsii_name="bucket")
    def _bucket(self) -> _aws_cdk_aws_s3_ceddda9d.IBucket:
        '''
        :stability: experimental
        '''
        return typing.cast(_aws_cdk_aws_s3_ceddda9d.IBucket, jsii.get(self, "bucket"))

    @builtins.property
    @jsii.member(jsii_name="isS3Reference")
    def is_s3_reference(self) -> builtins.bool:
        '''(experimental) Indicates that the provided component data is an S3 reference.

        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "isS3Reference"))

    @builtins.property
    @jsii.member(jsii_name="key")
    def _key(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "key"))


class _S3ComponentDataProxy(
    S3ComponentData,
    jsii.proxy_for(ComponentData), # type: ignore[misc]
):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, S3ComponentData).__jsii_proxy_class__ = lambda : _S3ComponentDataProxy


@jsii.data_type(
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.SSMParameterConfigurations",
    jsii_struct_bases=[],
    name_mapping={
        "parameter": "parameter",
        "ami_account": "amiAccount",
        "data_type": "dataType",
    },
)
class SSMParameterConfigurations:
    def __init__(
        self,
        *,
        parameter: _aws_cdk_aws_ssm_ceddda9d.IStringParameter,
        ami_account: typing.Optional[builtins.str] = None,
        data_type: typing.Optional[_aws_cdk_aws_ssm_ceddda9d.ParameterDataType] = None,
    ) -> None:
        '''(experimental) The SSM parameters to create or update for the distributed AMIs.

        :param parameter: (experimental) The SSM parameter to create or update.
        :param ami_account: (experimental) The AWS account ID that will own the SSM parameter in the given region. This must be one of the target accounts that was included in the list of AMI distribution target accounts Default: The current account is used
        :param data_type: (experimental) The data type of the SSM parameter. Default: ssm.ParameterDataType.AWS_EC2_IMAGE

        :stability: experimental
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk.aws_imagebuilder_alpha as imagebuilder_alpha
            from aws_cdk import aws_ssm as ssm
            
            # string_parameter: ssm.StringParameter
            
            s_sMParameter_configurations = imagebuilder_alpha.SSMParameterConfigurations(
                parameter=string_parameter,
            
                # the properties below are optional
                ami_account="amiAccount",
                data_type=ssm.ParameterDataType.TEXT
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c8c69f6418914aecbc11661f47678dc487ec81badbe17d0b392aff21a8c9943f)
            check_type(argname="argument parameter", value=parameter, expected_type=type_hints["parameter"])
            check_type(argname="argument ami_account", value=ami_account, expected_type=type_hints["ami_account"])
            check_type(argname="argument data_type", value=data_type, expected_type=type_hints["data_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "parameter": parameter,
        }
        if ami_account is not None:
            self._values["ami_account"] = ami_account
        if data_type is not None:
            self._values["data_type"] = data_type

    @builtins.property
    def parameter(self) -> _aws_cdk_aws_ssm_ceddda9d.IStringParameter:
        '''(experimental) The SSM parameter to create or update.

        :stability: experimental
        '''
        result = self._values.get("parameter")
        assert result is not None, "Required property 'parameter' is missing"
        return typing.cast(_aws_cdk_aws_ssm_ceddda9d.IStringParameter, result)

    @builtins.property
    def ami_account(self) -> typing.Optional[builtins.str]:
        '''(experimental) The AWS account ID that will own the SSM parameter in the given region.

        This must be one of the target accounts
        that was included in the list of AMI distribution target accounts

        :default: The current account is used

        :stability: experimental
        '''
        result = self._values.get("ami_account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def data_type(self) -> typing.Optional[_aws_cdk_aws_ssm_ceddda9d.ParameterDataType]:
        '''(experimental) The data type of the SSM parameter.

        :default: ssm.ParameterDataType.AWS_EC2_IMAGE

        :stability: experimental
        '''
        result = self._values.get("data_type")
        return typing.cast(typing.Optional[_aws_cdk_aws_ssm_ceddda9d.ParameterDataType], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SSMParameterConfigurations(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="@aws-cdk/aws-imagebuilder-alpha.Tenancy")
class Tenancy(enum.Enum):
    '''(experimental) The tenancy to use for an instance.

    :see: https://docs.aws.amazon.com/imagebuilder/latest/APIReference/API_Placement.html#imagebuilder-Type-Placement-tenancy
    :stability: experimental
    :exampleMetadata: infused

    Example::

        infrastructure_configuration = imagebuilder.InfrastructureConfiguration(self, "InfrastructureConfiguration",
            infrastructure_configuration_name="test-infrastructure-configuration",
            description="An Infrastructure Configuration",
            # Optional - instance types to use for build/test
            instance_types=[
                ec2.InstanceType.of(ec2.InstanceClass.STANDARD7_INTEL, ec2.InstanceSize.LARGE),
                ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.LARGE)
            ],
            # Optional - create an instance profile with necessary permissions
            instance_profile=iam.InstanceProfile(self, "InstanceProfile",
                instance_profile_name="test-instance-profile",
                role=iam.Role(self, "InstanceProfileRole",
                    assumed_by=iam.ServicePrincipal.from_static_service_principle_name("ec2.amazonaws.com"),
                    managed_policies=[
                        iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSSMManagedInstanceCore"),
                        iam.ManagedPolicy.from_aws_managed_policy_name("EC2InstanceProfileForImageBuilder")
                    ]
                )
            ),
            # Use VPC network configuration
            vpc=vpc,
            subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
            security_groups=[ec2.SecurityGroup.from_security_group_id(self, "SecurityGroup", vpc.vpc_default_security_group)],
            key_pair=ec2.KeyPair.from_key_pair_name(self, "KeyPair", "imagebuilder-instance-key-pair"),
            terminate_instance_on_failure=True,
            # Optional - IMDSv2 settings
            http_tokens=imagebuilder.HttpTokens.REQUIRED,
            http_put_response_hop_limit=1,
            # Optional - publish image completion messages to an SNS topic
            notification_topic=sns.Topic.from_topic_arn(self, "Topic",
                self.format_arn(service="sns", resource="image-builder-topic")),
            # Optional - log settings. Logging is enabled by default
            logging=imagebuilder.InfrastructureConfigurationLogging(
                s3_bucket=s3.Bucket.from_bucket_name(self, "LogBucket", f"imagebuilder-logging-{Aws.ACCOUNT_ID}"),
                s3_key_prefix="imagebuilder-logs"
            ),
            # Optional - host placement settings
            ec2_instance_availability_zone=Stack.of(self).availability_zones[0],
            ec2_instance_host_id=dedicated_host.attr_host_id,
            ec2_instance_tenancy=imagebuilder.Tenancy.HOST,
            resource_tags={
                "Environment": "production"
            }
        )
    '''

    DEFAULT = "DEFAULT"
    '''(experimental) Instances will be launched with default tenancy.

    :stability: experimental
    '''
    DEDICATED = "DEDICATED"
    '''(experimental) Instances will be launched with dedicated tenancy.

    :stability: experimental
    '''
    HOST = "HOST"
    '''(experimental) Instances will be launched on a dedicated host.

    :stability: experimental
    '''


@jsii.implements(IComponent)
class Component(
    _aws_cdk_ceddda9d.Resource,
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.Component",
):
    '''(experimental) Represents an EC2 Image Builder Component.

    :see: https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-components.html
    :stability: experimental
    :exampleMetadata: infused

    Example::

        component = imagebuilder.Component(self, "MyComponent",
            platform=imagebuilder.Platform.LINUX,
            data=imagebuilder.ComponentData.from_json_object({
                "schema_version": imagebuilder.ComponentSchemaVersion.V1_0,
                "phases": [{
                    "name": imagebuilder.ComponentPhaseName.BUILD,
                    "steps": [{
                        "name": "install-app",
                        "action": imagebuilder.ComponentAction.EXECUTE_BASH,
                        "inputs": {
                            "commands": ["echo \"Installing my application...\"", "yum update -y"]
                        }
                    }
                    ]
                }
                ]
            })
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        data: ComponentData,
        platform: Platform,
        change_description: typing.Optional[builtins.str] = None,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
        supported_os_versions: typing.Optional[typing.Sequence[OSVersion]] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param data: (experimental) The component document content that defines the build, validation, or test steps to be executed during the image building process.
        :param platform: (experimental) The operating system platform of the component.
        :param change_description: (experimental) The change description of the component. Describes what change has been made in this version of the component, or what makes this version different from other versions. Default: None
        :param component_name: (experimental) The name of the component. Default: - a name is generated
        :param component_version: (experimental) The version of the component. Default: 1.0.0
        :param description: (experimental) The description of the component. Default: None
        :param kms_key: (experimental) The KMS key used to encrypt this component. Default: - an Image Builder owned key will be used to encrypt the component.
        :param supported_os_versions: (experimental) The operating system versions supported by the component. Default: None
        :param tags: (experimental) The tags to apply to the component. Default: None

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__821af830fe4669e7ab6c5b515ddf450036e43237ed7a7ea4daa79141efaecef1)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = ComponentProps(
            data=data,
            platform=platform,
            change_description=change_description,
            component_name=component_name,
            component_version=component_version,
            description=description,
            kms_key=kms_key,
            supported_os_versions=supported_os_versions,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromComponentArn")
    @builtins.classmethod
    def from_component_arn(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        component_arn: builtins.str,
    ) -> IComponent:
        '''(experimental) Import an existing component given its ARN.

        :param scope: -
        :param id: -
        :param component_arn: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cfd3696ebfc0965153ddc80c27294aa75eba17b75effa00c9bb472513a1c896f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument component_arn", value=component_arn, expected_type=type_hints["component_arn"])
        return typing.cast(IComponent, jsii.sinvoke(cls, "fromComponentArn", [scope, id, component_arn]))

    @jsii.member(jsii_name="fromComponentAttributes")
    @builtins.classmethod
    def from_component_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        component_arn: typing.Optional[builtins.str] = None,
        component_name: typing.Optional[builtins.str] = None,
        component_version: typing.Optional[builtins.str] = None,
    ) -> IComponent:
        '''(experimental) Import an existing component by providing its attributes.

        If the component name is provided as an attribute, it
        must be normalized by converting all alphabetical characters to lowercase, and replacing all spaces and underscores
        with hyphens.

        :param scope: -
        :param id: -
        :param component_arn: (experimental) The ARN of the component. Default: - the ARN is automatically constructed if a componentName is provided, otherwise a componentArn is required
        :param component_name: (experimental) The name of the component. Default: - the name is automatically constructed if a componentArn is provided, otherwise a componentName is required
        :param component_version: (experimental) The version of the component. Default: - the latest version of the component, x.x.x

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__855ab91348e9a8f975e485b8a62a964df50c942f63ab667e01e7d63dbb4c7a0e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = ComponentAttributes(
            component_arn=component_arn,
            component_name=component_name,
            component_version=component_version,
        )

        return typing.cast(IComponent, jsii.sinvoke(cls, "fromComponentAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="fromComponentName")
    @builtins.classmethod
    def from_component_name(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        component_name: builtins.str,
    ) -> IComponent:
        '''(experimental) Import an existing component given its name.

        The provided name must be normalized by converting all alphabetical
        characters to lowercase, and replacing all spaces and underscores with hyphens.

        :param scope: -
        :param id: -
        :param component_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bc6fec412b104b8ebb0eb1becd579dd790fd8b15f8a325c62a139498c1c1e16f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument component_name", value=component_name, expected_type=type_hints["component_name"])
        return typing.cast(IComponent, jsii.sinvoke(cls, "fromComponentName", [scope, id, component_name]))

    @jsii.member(jsii_name="isComponent")
    @builtins.classmethod
    def is_component(cls, x: typing.Any) -> builtins.bool:
        '''(experimental) Return whether the given object is a Component.

        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2e53a5c2eecca10be8fe0de193fb3e2a0e5fd9773e5f63ad62b925d179b954fb)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isComponent", [x]))

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the component.

        :param grantee: The principal.
        :param actions: The list of actions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7b5b31f435c4629c89b4f258618167515bf0149ce8e4a65bc41d5edfe8e6e30a)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument actions", value=actions, expected_type=typing.Tuple[type_hints["actions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grant", [grantee, *actions]))

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the component.

        :param grantee: The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__42a34b26472675ab353df57d1bba08682c320d94f42e392d792c8cc9e26064be)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [grantee]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
        '''(experimental) Uniquely identifies this class.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))

    @builtins.property
    @jsii.member(jsii_name="componentArn")
    def component_arn(self) -> builtins.str:
        '''(experimental) The ARN of the component.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "componentArn"))

    @builtins.property
    @jsii.member(jsii_name="componentName")
    def component_name(self) -> builtins.str:
        '''(experimental) The name of the component.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "componentName"))

    @builtins.property
    @jsii.member(jsii_name="componentType")
    def component_type(self) -> builtins.str:
        '''(experimental) The type of the component.

        :stability: experimental
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "componentType"))

    @builtins.property
    @jsii.member(jsii_name="componentVersion")
    def component_version(self) -> builtins.str:
        '''(experimental) The version of the component.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "componentVersion"))

    @builtins.property
    @jsii.member(jsii_name="encrypted")
    def encrypted(self) -> builtins.bool:
        '''(experimental) Whether the component is encrypted.

        :stability: experimental
        '''
        return typing.cast(builtins.bool, jsii.get(self, "encrypted"))

    @builtins.property
    @jsii.member(jsii_name="kmsKey")
    def _kms_key(self) -> typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey], jsii.get(self, "kmsKey"))


@jsii.implements(IDistributionConfiguration)
class DistributionConfiguration(
    _aws_cdk_ceddda9d.Resource,
    metaclass=jsii.JSIIMeta,
    jsii_type="@aws-cdk/aws-imagebuilder-alpha.DistributionConfiguration",
):
    '''(experimental) Represents an EC2 Image Builder Distribution Configuration.

    :see: https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-distribution-settings.html
    :stability: experimental
    :exampleMetadata: infused

    Example::

        distribution_configuration = imagebuilder.DistributionConfiguration(self, "DistributionConfiguration",
            distribution_configuration_name="test-distribution-configuration",
            description="A Distribution Configuration",
            ami_distributions=[imagebuilder.AmiDistribution(
                # Distribute AMI to us-east-2 and publish the AMI ID to an SSM parameter
                region="us-east-2",
                ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                    parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossRegionParameter",
                        parameter_name="/imagebuilder/ami",
                        force_dynamic_reference=True
                    )
                )
                ]
            )
            ]
        )
        
        # For AMI-based image builds - add an AMI distribution in the current region
        distribution_configuration.add_ami_distributions(
            ami_name="imagebuilder-{{ imagebuilder:buildDate }}",
            ami_description="Build AMI",
            ami_kms_key=kms.Key.from_lookup(self, "ComponentKey", alias_name="alias/distribution-encryption-key"),
            # Copy the AMI to different accounts
            ami_target_account_ids=["123456789012", "098765432109"],
            # Add launch permissions on the AMI
            ami_launch_permission=imagebuilder.AmiLaunchPermission(
                organization_arns=[
                    self.format_arn(region="", service="organizations", resource="organization", resource_name="o-1234567abc")
                ],
                organizational_unit_arns=[
                    self.format_arn(
                        region="",
                        service="organizations",
                        resource="ou",
                        resource_name="o-1234567abc/ou-a123-b4567890"
                    )
                ],
                is_public_user_group=True,
                account_ids=["234567890123"]
            ),
            # Attach tags to the AMI
            ami_tags={
                "Environment": "production",
                "Version": "{{ imagebuilder:buildVersion }}"
            },
            # Optional - publish the distributed AMI ID to an SSM parameter
            ssm_parameters=[imagebuilder.SSMParameterConfigurations(
                parameter=ssm.StringParameter.from_string_parameter_attributes(self, "Parameter",
                    parameter_name="/imagebuilder/ami",
                    force_dynamic_reference=True
                )
            ), imagebuilder.SSMParameterConfigurations(
                ami_account="098765432109",
                data_type=ssm.ParameterDataType.TEXT,
                parameter=ssm.StringParameter.from_string_parameter_attributes(self, "CrossAccountParameter",
                    parameter_name="imagebuilder-prod-ami",
                    force_dynamic_reference=True
                )
            )
            ],
            # Optional - create a new launch template version with the distributed AMI ID
            launch_templates=[imagebuilder.LaunchTemplateConfiguration(
                launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "LaunchTemplate",
                    launch_template_id="lt-1234"
                ),
                set_default_version=True
            ), imagebuilder.LaunchTemplateConfiguration(
                account_id="123456789012",
                launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "CrossAccountLaunchTemplate",
                    launch_template_id="lt-5678"
                ),
                set_default_version=True
            )
            ],
            # Optional - enable Fast Launch on an imported launch template
            fast_launch_configurations=[imagebuilder.FastLaunchConfiguration(
                enabled=True,
                launch_template=ec2.LaunchTemplate.from_launch_template_attributes(self, "FastLaunchLT",
                    launch_template_name="fast-launch-lt"
                ),
                max_parallel_launches=10,
                target_snapshot_count=2
            )
            ],
            # Optional - license configurations to apply to the AMI
            license_configuration_arns=["arn:aws:license-manager:us-west-2:123456789012:license-configuration:lic-abcdefghijklmnopqrstuvwxyz"
            ]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        ami_distributions: typing.Optional[typing.Sequence[typing.Union[AmiDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
        container_distributions: typing.Optional[typing.Sequence[typing.Union[ContainerDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
        description: typing.Optional[builtins.str] = None,
        distribution_configuration_name: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param ami_distributions: (experimental) The list of target regions and associated AMI distribution settings where the built AMI will be distributed. AMI distributions may also be added with the ``addAmiDistributions`` method. Default: None if container distributions are provided. Otherwise, at least one AMI or container distribution must be provided
        :param container_distributions: (experimental) The list of target regions and associated container distribution settings where the built container will be distributed. Container distributions may also be added with the ``addContainerDistributions`` method. Default: None if AMI distributions are provided. Otherwise, at least one AMI or container distribution must be provided
        :param description: (experimental) The description of the distribution configuration. Default: None
        :param distribution_configuration_name: (experimental) The name of the distribution configuration. Default: A name is generated
        :param tags: (experimental) The tags to apply to the distribution configuration. Default: None

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11d3b64e9f6b2ee2d3b14d4e9e47b654d28b8b1fc3fa8dea006c45f12fca43a4)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = DistributionConfigurationProps(
            ami_distributions=ami_distributions,
            container_distributions=container_distributions,
            description=description,
            distribution_configuration_name=distribution_configuration_name,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromDistributionConfigurationArn")
    @builtins.classmethod
    def from_distribution_configuration_arn(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        distribution_configuration_arn: builtins.str,
    ) -> IDistributionConfiguration:
        '''(experimental) Import an existing distribution configuration given its ARN.

        :param scope: -
        :param id: -
        :param distribution_configuration_arn: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__af172824cb5c143f0efbf3117bc59db39ad72fce677d46a164a9e803d61ec34f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument distribution_configuration_arn", value=distribution_configuration_arn, expected_type=type_hints["distribution_configuration_arn"])
        return typing.cast(IDistributionConfiguration, jsii.sinvoke(cls, "fromDistributionConfigurationArn", [scope, id, distribution_configuration_arn]))

    @jsii.member(jsii_name="fromDistributionConfigurationName")
    @builtins.classmethod
    def from_distribution_configuration_name(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        distribution_configuration_name: builtins.str,
    ) -> IDistributionConfiguration:
        '''(experimental) Import an existing distribution configuration given its name.

        The provided name must be normalized by converting
        all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.

        :param scope: -
        :param id: -
        :param distribution_configuration_name: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79a8c170425f7540a2fdc34caebbab7f83b2b5dad9f689bd2c9bb8fef61df566)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument distribution_configuration_name", value=distribution_configuration_name, expected_type=type_hints["distribution_configuration_name"])
        return typing.cast(IDistributionConfiguration, jsii.sinvoke(cls, "fromDistributionConfigurationName", [scope, id, distribution_configuration_name]))

    @jsii.member(jsii_name="isDistributionConfiguration")
    @builtins.classmethod
    def is_distribution_configuration(cls, x: typing.Any) -> builtins.bool:
        '''(experimental) Return whether the given object is a DistributionConfiguration.

        :param x: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e875d815d7fce8de551a2b7ca7d67241b9174bff80334d12c760431295c2b620)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isDistributionConfiguration", [x]))

    @jsii.member(jsii_name="addAmiDistributions")
    def add_ami_distributions(self, *ami_distributions: AmiDistribution) -> None:
        '''(experimental) Adds AMI distribution settings to the distribution configuration.

        :param ami_distributions: The list of AMI distribution settings to apply.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3cf357449b11fb13199b1274b1f2ecc286d438f3066b3854934da18ccd64a988)
            check_type(argname="argument ami_distributions", value=ami_distributions, expected_type=typing.Tuple[type_hints["ami_distributions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addAmiDistributions", [*ami_distributions]))

    @jsii.member(jsii_name="addContainerDistributions")
    def add_container_distributions(
        self,
        *container_distributions: ContainerDistribution,
    ) -> None:
        '''(experimental) Adds container distribution settings to the distribution configuration.

        :param container_distributions: The list of container distribution settings to apply.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b84d6f6541e69607800d8d08bd8a584f1abf3776893226fd8020fab23dfb21ac)
            check_type(argname="argument container_distributions", value=container_distributions, expected_type=typing.Tuple[type_hints["container_distributions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addContainerDistributions", [*container_distributions]))

    @jsii.member(jsii_name="grant")
    def grant(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
        *actions: builtins.str,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant custom actions to the given grantee for the distribution configuration.

        :param grantee: The principal.
        :param actions: The list of actions.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9b0fd339a1dc53ecc72e60e1ff7801f259edf211b35356c71fbf6f5c32d6367c)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument actions", value=actions, expected_type=typing.Tuple[type_hints["actions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grant", [grantee, *actions]))

    @jsii.member(jsii_name="grantRead")
    def grant_read(
        self,
        grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
        '''(experimental) Grant read permissions to the given grantee for the distribution configuration.

        :param grantee: The principal.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__90ca521312fb50ebc6b1949574749352f71bd6afecb49058e89da3130e5b8f73)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [grantee]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
        '''(experimental) Uniquely identifies this class.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))

    @builtins.property
    @jsii.member(jsii_name="distributionConfigurationArn")
    def distribution_configuration_arn(self) -> builtins.str:
        '''(experimental) The ARN of the distribution configuration.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "distributionConfigurationArn"))

    @builtins.property
    @jsii.member(jsii_name="distributionConfigurationName")
    def distribution_configuration_name(self) -> builtins.str:
        '''(experimental) The name of the distribution configuration.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "distributionConfigurationName"))


__all__ = [
    "AmiDistribution",
    "AmiLaunchPermission",
    "AwsManagedComponent",
    "AwsManagedComponentAttributes",
    "AwsMarketplaceComponent",
    "AwsMarketplaceComponentAttributes",
    "Component",
    "ComponentAction",
    "ComponentAttributes",
    "ComponentConstantValue",
    "ComponentData",
    "ComponentDocument",
    "ComponentDocumentForLoop",
    "ComponentDocumentLoop",
    "ComponentDocumentParameterDefinition",
    "ComponentDocumentPhase",
    "ComponentDocumentStep",
    "ComponentOnFailure",
    "ComponentParameterType",
    "ComponentPhaseName",
    "ComponentProps",
    "ComponentSchemaVersion",
    "ComponentStepIfCondition",
    "ComponentStepInputs",
    "ContainerDistribution",
    "DistributionConfiguration",
    "DistributionConfigurationProps",
    "FastLaunchConfiguration",
    "HttpTokens",
    "IComponent",
    "IDistributionConfiguration",
    "IInfrastructureConfiguration",
    "InfrastructureConfiguration",
    "InfrastructureConfigurationLogging",
    "InfrastructureConfigurationProps",
    "LaunchTemplateConfiguration",
    "OSVersion",
    "Platform",
    "Repository",
    "RepositoryService",
    "S3ComponentData",
    "SSMParameterConfigurations",
    "Tenancy",
]

publication.publish()

def _typecheckingstub__6bbb50c8ed5cb401fdf362f5d0a7b629c2c082dbdaadf32bcf6aef95e968f20b(
    *,
    ami_description: typing.Optional[builtins.str] = None,
    ami_kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    ami_launch_permission: typing.Optional[typing.Union[AmiLaunchPermission, typing.Dict[builtins.str, typing.Any]]] = None,
    ami_name: typing.Optional[builtins.str] = None,
    ami_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ami_target_account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    fast_launch_configurations: typing.Optional[typing.Sequence[typing.Union[FastLaunchConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
    launch_templates: typing.Optional[typing.Sequence[typing.Union[LaunchTemplateConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
    license_configuration_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    region: typing.Optional[builtins.str] = None,
    ssm_parameters: typing.Optional[typing.Sequence[typing.Union[SSMParameterConfigurations, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c99475ef38f88d24e515c5d4cfe68b2b801bf8855b6659a379ba52bbf9fc1a2e(
    *,
    account_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    is_public_user_group: typing.Optional[builtins.bool] = None,
    organizational_unit_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    organization_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28a85b2f57e866c107d58316256ca41b5310ce1316357a3af47fb8c9be257978(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0eb8b88fb01463e77d65e8b3815c5fe4a9d52d5ed7d626bea7c9e5bdd7e3c933(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1627b69c7ba0f04ae9ab6f1180bac6dcb468a367c684ce2ad9e056fe1b690dd7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    aws_managed_component_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e95cc80beec8557aaefdf226beed47b803646d97e987b28db9a477824f800fe7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b92acbc29e4089fea8f68555361bc22819eb5f63eadda40faf19d3a828fb29fc(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__69ab4d7f7fe572f41496187a8f5fd08b3dfdbbe78d1aa9cf5265d61d84e8ecbe(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ee53616f10cfba26195e210fe4dc7bcff71fa4a63c9e6648e4025ee62fafedcc(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d19311b8326a0517457ce310fe53e0167cc068a7f8d5c49cc1a577e6fa7d0cd2(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32e146149e9a0c45e3993363b6a87d969c0d980b08ea6bb731b42f52f28c04dd(
    *,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    platform: typing.Optional[Platform] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__72fea4585ffbd64de79c39d71516ff9636b95dece6fff22dc33683909474b7ea(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_name: builtins.str,
    marketplace_product_id: builtins.str,
    component_version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7239391743877da3432bdb2ba2d1e3c8b1e460c607e06086757dd481b60551dc(
    *,
    component_name: builtins.str,
    marketplace_product_id: builtins.str,
    component_version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a111ce6a3cc980fdfd78a9c04008d2621e0cdb5a73ac895dcac5188565ad834a(
    *,
    component_arn: typing.Optional[builtins.str] = None,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7a022302a19d26bbe18edf3fafb69d72fca2ee4e1f292dafa9ce24d08a9455c(
    type: builtins.str,
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__963a239c9c403fc6b5a4313e8e62b5aa83e3dfcb87d450ca08bbee183cbac1d4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__edbe027f8c3d7062dfc1c03bb55eb927c328b9cd602143575a35fa311f551f29(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3dd9994d6bd946b1ceac062da8831ad7f0ab68167221bcb1de2b5bf4f1b9389(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    path: builtins.str,
    *,
    deploy_time: typing.Optional[builtins.bool] = None,
    display_name: typing.Optional[builtins.str] = None,
    readers: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.IGrantable]] = None,
    source_kms_key: typing.Optional[_aws_cdk_interfaces_aws_kms_ceddda9d.IKeyRef] = None,
    asset_hash: typing.Optional[builtins.str] = None,
    asset_hash_type: typing.Optional[_aws_cdk_ceddda9d.AssetHashType] = None,
    bundling: typing.Optional[typing.Union[_aws_cdk_ceddda9d.BundlingOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
    follow_symlinks: typing.Optional[_aws_cdk_ceddda9d.SymlinkFollowMode] = None,
    ignore_mode: typing.Optional[_aws_cdk_ceddda9d.IgnoreMode] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e5c968d474a4be4f05abdfab6bd5b4d52a49ade7db8a0614bd22bc59fe1dbb4(
    data: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e62d9de5f9eddd59dcfb4d4419326a2af5a8035493101b1595b1a55234425ab(
    data: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__502ae41b418b170f33bf886f3f817d134270c2d3c6d326d7017b7da013816b35(
    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
    key: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4737aa013938586441da1b86dab7eebc204c3816be9ffb4b4666db7f4c154a3c(
    *,
    phases: typing.Sequence[typing.Union[ComponentDocumentPhase, typing.Dict[builtins.str, typing.Any]]],
    schema_version: ComponentSchemaVersion,
    constants: typing.Optional[typing.Mapping[builtins.str, ComponentConstantValue]] = None,
    description: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    parameters: typing.Optional[typing.Mapping[builtins.str, typing.Union[ComponentDocumentParameterDefinition, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7545616e7ad4244bf8e5212a06dc04473a71fef0517840bdfaf4168ea419c44(
    *,
    end: jsii.Number,
    start: jsii.Number,
    update_by: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__016c7a2af8ebcf03286820555388bbfa1ccb89028f5f37b87fa3f7cb9dceded7(
    *,
    for_: typing.Optional[typing.Union[ComponentDocumentForLoop, typing.Dict[builtins.str, typing.Any]]] = None,
    for_each: typing.Optional[typing.Sequence[builtins.str]] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7b765c0d6f7d805699670929833be905f563259a2aec778f1d09ab1ac16f76c5(
    *,
    type: ComponentParameterType,
    default: typing.Any = None,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3717a69557789288ecb2866be7254e9e0d4db1c92bd936b8be1466c3858d8a51(
    *,
    name: ComponentPhaseName,
    steps: typing.Sequence[typing.Union[ComponentDocumentStep, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da991558ffc8ca306ecc6999d0b287568416629c1073bde551fb7c089193ce5c(
    *,
    action: ComponentAction,
    inputs: ComponentStepInputs,
    name: builtins.str,
    if_: typing.Optional[ComponentStepIfCondition] = None,
    loop: typing.Optional[typing.Union[ComponentDocumentLoop, typing.Dict[builtins.str, typing.Any]]] = None,
    on_failure: typing.Optional[ComponentOnFailure] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dafb5f8cd0f4ef40e1c882755f37fc5dc1a69e4a81d5826049e0c91bf971be3a(
    *,
    data: ComponentData,
    platform: Platform,
    change_description: typing.Optional[builtins.str] = None,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    supported_os_versions: typing.Optional[typing.Sequence[OSVersion]] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28e9b0814cd916ca01f8a7cf48021bfcd01d4c17be3ae2253fe86dd86f93d671(
    if_condition: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd7bb86c499fa1670bd8e78f1bd8542abc56e983e69f40e47d32019e6656ffcc(
    if_object: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9e53ae7d6d8c31ee6012880e97dd97ea37ce68d0a35e0216830ea8ab676a9ec3(
    input: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79e97a2950e23ff264bda320a66d7ece7c77f491b953c2d2b71cb4ece4c553e4(
    inputs_object_list: typing.Sequence[typing.Mapping[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61535270ffc68df1496f99af681d722e10151c09b0576885b939d7919cfb56b2(
    inputs_object: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e915667467bed957a52d2238405ebf79ca421c029bc891bb818483871e32a658(
    *,
    container_repository: Repository,
    container_description: typing.Optional[builtins.str] = None,
    container_tags: typing.Optional[typing.Sequence[builtins.str]] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00a08291003318bd50149ef24f2bb14662ca021351848559c22243f8c7a24a58(
    *,
    ami_distributions: typing.Optional[typing.Sequence[typing.Union[AmiDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
    container_distributions: typing.Optional[typing.Sequence[typing.Union[ContainerDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
    description: typing.Optional[builtins.str] = None,
    distribution_configuration_name: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b90ae1e7cf235ef00d4a47bdf413ccd7ca19785b18e7f91a75464655f60195df(
    *,
    enabled: typing.Optional[builtins.bool] = None,
    launch_template: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate] = None,
    max_parallel_launches: typing.Optional[jsii.Number] = None,
    target_snapshot_count: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c05d6ee1a3eb8c5f9b0d715b586bd51b2a253ebbcc8dae51c78ae2c159bf057(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    *actions: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__841448c6baa993d7b4b3033a5490d19f411b8aebe362b78bd7e0490c73bd22d1(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0a9dae8c4b2356a5fed2efe8df76a59819e04e2a8562b9fe922537ca4b6313be(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    *actions: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e644849da79fab144eff75407555da79d5543225778e3d852909fa3b1a1d2933(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8f4ed7436405bcfb3a075aa5c93725806206943d8dbaa96c5cef8dd4d46cae37(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    *actions: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2582830fbd4fc0772d12414b5d2346ecedd7b1bb8582db47fa079012ef22197(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f8672dd2c6991d2ba23136620a37140cb449f0b7606cfe5538649d44bc009387(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    ec2_instance_availability_zone: typing.Optional[builtins.str] = None,
    ec2_instance_host_id: typing.Optional[builtins.str] = None,
    ec2_instance_host_resource_group_arn: typing.Optional[builtins.str] = None,
    ec2_instance_tenancy: typing.Optional[Tenancy] = None,
    http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
    http_tokens: typing.Optional[HttpTokens] = None,
    infrastructure_configuration_name: typing.Optional[builtins.str] = None,
    instance_profile: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IInstanceProfile] = None,
    instance_types: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.InstanceType]] = None,
    key_pair: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IKeyPair] = None,
    logging: typing.Optional[typing.Union[InfrastructureConfigurationLogging, typing.Dict[builtins.str, typing.Any]]] = None,
    notification_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    resource_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
    security_groups: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]] = None,
    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    terminate_instance_on_failure: typing.Optional[builtins.bool] = None,
    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__35015fe2e49bc142df9482904b92351bbc9b41c560cac1ac06713b2b564cd982(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    infrastructure_configuration_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3d30c941bd6f0f1b07145f10c999bbeef38a9fbbc483fdfb4e54de8301a42bd6(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    infrastructure_configuration_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__653ebae43bf6b6e095ea87727d122e7cab0c8786387877992a5a7e642a846e02(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d73bd89218669ef1c777360509401b7db5901968dd024b757f3c75f85ccd1228(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    *actions: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61c74f957e8c879932590c0d74b45224a68ab6d8eca577948a171e837ccc4cda(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__74cffe7aa25819eaef361f450e04e7112a9f46a9d0138a9696f9723b55a1d31d(
    *,
    s3_bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
    s3_key_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__07545a4f62a3521f9640beafa4b4d7cc1fbe20fc1df54541287ed96ffe7f8e4e(
    *,
    description: typing.Optional[builtins.str] = None,
    ec2_instance_availability_zone: typing.Optional[builtins.str] = None,
    ec2_instance_host_id: typing.Optional[builtins.str] = None,
    ec2_instance_host_resource_group_arn: typing.Optional[builtins.str] = None,
    ec2_instance_tenancy: typing.Optional[Tenancy] = None,
    http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
    http_tokens: typing.Optional[HttpTokens] = None,
    infrastructure_configuration_name: typing.Optional[builtins.str] = None,
    instance_profile: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IInstanceProfile] = None,
    instance_types: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.InstanceType]] = None,
    key_pair: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IKeyPair] = None,
    logging: typing.Optional[typing.Union[InfrastructureConfigurationLogging, typing.Dict[builtins.str, typing.Any]]] = None,
    notification_topic: typing.Optional[_aws_cdk_aws_sns_ceddda9d.ITopic] = None,
    resource_tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
    security_groups: typing.Optional[typing.Sequence[_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup]] = None,
    subnet_selection: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    terminate_instance_on_failure: typing.Optional[builtins.bool] = None,
    vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7488a156223bbf9e56775eef019a0bfc54d1cbe34be84e101b6775196600d51d(
    *,
    launch_template: _aws_cdk_aws_ec2_ceddda9d.ILaunchTemplate,
    account_id: typing.Optional[builtins.str] = None,
    set_default_version: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5e835db1a09fe43e2d622f4324c6ace2e9dbd991bf060bc80994a8c7f278814(
    platform: Platform,
    os_version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff5a2c2e2f508c6ffd9d7b790056aed4fb62718c2288d6565e09783a7327d151(
    platform: Platform,
    os_version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bf80e8cbc35b94d36db54f92df03bee46b372adfb0f2a76712eaf0f716c17c3e(
    repository: _aws_cdk_aws_ecr_ceddda9d.IRepository,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d8cfdd61801a768cf18184f1eb0737a88d90c072ea930a509e6fe06fcff393d8(
    bucket: _aws_cdk_aws_s3_ceddda9d.IBucket,
    key: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cc38fb84d23f869830d4eb53138914295325097f770e7d5bd62c28c8cedaaa0c(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__022e6141b2cc124364e4bd232e91e64e60212165c7aca9e98a54c50a7b0e1bb7(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c8c69f6418914aecbc11661f47678dc487ec81badbe17d0b392aff21a8c9943f(
    *,
    parameter: _aws_cdk_aws_ssm_ceddda9d.IStringParameter,
    ami_account: typing.Optional[builtins.str] = None,
    data_type: typing.Optional[_aws_cdk_aws_ssm_ceddda9d.ParameterDataType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__821af830fe4669e7ab6c5b515ddf450036e43237ed7a7ea4daa79141efaecef1(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    data: ComponentData,
    platform: Platform,
    change_description: typing.Optional[builtins.str] = None,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    supported_os_versions: typing.Optional[typing.Sequence[OSVersion]] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cfd3696ebfc0965153ddc80c27294aa75eba17b75effa00c9bb472513a1c896f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    component_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__855ab91348e9a8f975e485b8a62a964df50c942f63ab667e01e7d63dbb4c7a0e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    component_arn: typing.Optional[builtins.str] = None,
    component_name: typing.Optional[builtins.str] = None,
    component_version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bc6fec412b104b8ebb0eb1becd579dd790fd8b15f8a325c62a139498c1c1e16f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    component_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2e53a5c2eecca10be8fe0de193fb3e2a0e5fd9773e5f63ad62b925d179b954fb(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7b5b31f435c4629c89b4f258618167515bf0149ce8e4a65bc41d5edfe8e6e30a(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    *actions: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__42a34b26472675ab353df57d1bba08682c320d94f42e392d792c8cc9e26064be(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11d3b64e9f6b2ee2d3b14d4e9e47b654d28b8b1fc3fa8dea006c45f12fca43a4(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    ami_distributions: typing.Optional[typing.Sequence[typing.Union[AmiDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
    container_distributions: typing.Optional[typing.Sequence[typing.Union[ContainerDistribution, typing.Dict[builtins.str, typing.Any]]]] = None,
    description: typing.Optional[builtins.str] = None,
    distribution_configuration_name: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__af172824cb5c143f0efbf3117bc59db39ad72fce677d46a164a9e803d61ec34f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    distribution_configuration_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79a8c170425f7540a2fdc34caebbab7f83b2b5dad9f689bd2c9bb8fef61df566(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    distribution_configuration_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e875d815d7fce8de551a2b7ca7d67241b9174bff80334d12c760431295c2b620(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3cf357449b11fb13199b1274b1f2ecc286d438f3066b3854934da18ccd64a988(
    *ami_distributions: AmiDistribution,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b84d6f6541e69607800d8d08bd8a584f1abf3776893226fd8020fab23dfb21ac(
    *container_distributions: ContainerDistribution,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b0fd339a1dc53ecc72e60e1ff7801f259edf211b35356c71fbf6f5c32d6367c(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
    *actions: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__90ca521312fb50ebc6b1949574749352f71bd6afecb49058e89da3130e5b8f73(
    grantee: _aws_cdk_aws_iam_ceddda9d.IGrantable,
) -> None:
    """Type checking stubs"""
    pass

for cls in [IComponent, IDistributionConfiguration, IInfrastructureConfiguration]:
    typing.cast(typing.Any, cls).__protocol_attrs__ = typing.cast(typing.Any, cls).__protocol_attrs__ - set(['__jsii_proxy_class__', '__jsii_type__'])
