# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._enums import *

__all__ = [
    'CapacityReservationTag',
    'CapacityReservationTagSpecification',
    'CarrierGatewayTag',
    'ClientVpnEndpointCertificateAuthenticationRequest',
    'ClientVpnEndpointClientAuthenticationRequest',
    'ClientVpnEndpointClientConnectOptions',
    'ClientVpnEndpointConnectionLogOptions',
    'ClientVpnEndpointDirectoryServiceAuthenticationRequest',
    'ClientVpnEndpointFederatedAuthenticationRequest',
    'ClientVpnEndpointTag',
    'ClientVpnEndpointTagSpecification',
    'CustomerGatewayTag',
    'DHCPOptionsTag',
    'EC2FleetCapacityReservationOptionsRequest',
    'EC2FleetFleetLaunchTemplateConfigRequest',
    'EC2FleetFleetLaunchTemplateOverridesRequest',
    'EC2FleetFleetLaunchTemplateSpecificationRequest',
    'EC2FleetOnDemandOptionsRequest',
    'EC2FleetPlacement',
    'EC2FleetSpotOptionsRequest',
    'EC2FleetTag',
    'EC2FleetTagSpecification',
    'EC2FleetTargetCapacitySpecificationRequest',
    'EIPTag',
    'FlowLogTag',
    'InstanceAssociationParameter',
    'InstanceBlockDeviceMapping',
    'InstanceCpuOptions',
    'InstanceCreditSpecification',
    'InstanceEbs',
    'InstanceElasticGpuSpecification',
    'InstanceElasticInferenceAccelerator',
    'InstanceEnclaveOptions',
    'InstanceHibernationOptions',
    'InstanceInstanceIpv6Address',
    'InstanceLaunchTemplateSpecification',
    'InstanceLicenseSpecification',
    'InstanceNetworkInterface',
    'InstanceNoDevice',
    'InstancePrivateIpAddressSpecification',
    'InstanceSsmAssociation',
    'InstanceTag',
    'InstanceVolume',
    'InternetGatewayTag',
    'LaunchTemplateBlockDeviceMapping',
    'LaunchTemplateCapacityReservationSpecification',
    'LaunchTemplateCapacityReservationTarget',
    'LaunchTemplateCpuOptions',
    'LaunchTemplateCreditSpecification',
    'LaunchTemplateEbs',
    'LaunchTemplateElasticGpuSpecification',
    'LaunchTemplateEnclaveOptions',
    'LaunchTemplateHibernationOptions',
    'LaunchTemplateIamInstanceProfile',
    'LaunchTemplateInstanceMarketOptions',
    'LaunchTemplateIpv6Add',
    'LaunchTemplateLaunchTemplateData',
    'LaunchTemplateLaunchTemplateElasticInferenceAccelerator',
    'LaunchTemplateLaunchTemplateTagSpecification',
    'LaunchTemplateLicenseSpecification',
    'LaunchTemplateMetadataOptions',
    'LaunchTemplateMonitoring',
    'LaunchTemplateNetworkInterface',
    'LaunchTemplatePlacement',
    'LaunchTemplatePrivateIpAdd',
    'LaunchTemplateSpotOptions',
    'LaunchTemplateTag',
    'LaunchTemplateTagSpecification',
    'LocalGatewayRouteTableVPCAssociationTag',
    'NatGatewayTag',
    'NetworkAclEntryIcmp',
    'NetworkAclEntryPortRange',
    'NetworkAclTag',
    'NetworkInsightsAnalysisAlternatePathHint',
    'NetworkInsightsAnalysisAnalysisAclRule',
    'NetworkInsightsAnalysisAnalysisComponent',
    'NetworkInsightsAnalysisAnalysisLoadBalancerListener',
    'NetworkInsightsAnalysisAnalysisLoadBalancerTarget',
    'NetworkInsightsAnalysisAnalysisPacketHeader',
    'NetworkInsightsAnalysisAnalysisRouteTableRoute',
    'NetworkInsightsAnalysisAnalysisSecurityGroupRule',
    'NetworkInsightsAnalysisExplanation',
    'NetworkInsightsAnalysisPathComponent',
    'NetworkInsightsAnalysisPortRange',
    'NetworkInsightsAnalysisTag',
    'NetworkInsightsPathTag',
    'NetworkInterfaceInstanceIpv6Address',
    'NetworkInterfacePrivateIpAddressSpecification',
    'NetworkInterfaceTag',
    'PrefixListEntry',
    'PrefixListTag',
    'RouteTableTag',
    'SecurityGroupEgress',
    'SecurityGroupIngress',
    'SecurityGroupTag',
    'SpotFleetBlockDeviceMapping',
    'SpotFleetClassicLoadBalancer',
    'SpotFleetClassicLoadBalancersConfig',
    'SpotFleetEbsBlockDevice',
    'SpotFleetFleetLaunchTemplateSpecification',
    'SpotFleetGroupIdentifier',
    'SpotFleetIamInstanceProfileSpecification',
    'SpotFleetInstanceIpv6Address',
    'SpotFleetInstanceNetworkInterfaceSpecification',
    'SpotFleetLaunchTemplateConfig',
    'SpotFleetLaunchTemplateOverrides',
    'SpotFleetLoadBalancersConfig',
    'SpotFleetPrivateIpAddressSpecification',
    'SpotFleetSpotCapacityRebalance',
    'SpotFleetSpotFleetLaunchSpecification',
    'SpotFleetSpotFleetMonitoring',
    'SpotFleetSpotFleetRequestConfigData',
    'SpotFleetSpotFleetTagSpecification',
    'SpotFleetSpotMaintenanceStrategies',
    'SpotFleetSpotPlacement',
    'SpotFleetTag',
    'SpotFleetTargetGroup',
    'SpotFleetTargetGroupsConfig',
    'SubnetTag',
    'TrafficMirrorFilterRuleTrafficMirrorPortRange',
    'TrafficMirrorFilterTag',
    'TrafficMirrorSessionTag',
    'TrafficMirrorTargetTag',
    'TransitGatewayAttachmentTag',
    'TransitGatewayConnectTag',
    'TransitGatewayConnectTransitGatewayConnectOptions',
    'TransitGatewayMulticastDomainTag',
    'TransitGatewayPeeringAttachmentPeeringAttachmentStatus',
    'TransitGatewayPeeringAttachmentTag',
    'TransitGatewayRouteTableTag',
    'TransitGatewayTag',
    'TransitGatewayVpcAttachmentTag',
    'VPCPeeringConnectionTag',
    'VPCTag',
    'VPNConnectionTag',
    'VPNConnectionVpnTunnelOptionsSpecification',
    'VPNGatewayTag',
    'VolumeTag',
]

@pulumi.output_type
class CapacityReservationTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class CapacityReservationTagSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceType":
            suggest = "resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CapacityReservationTagSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CapacityReservationTagSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CapacityReservationTagSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_type: Optional[str] = None,
                 tags: Optional[Sequence['outputs.CapacityReservationTag']] = None):
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence['outputs.CapacityReservationTag']]:
        return pulumi.get(self, "tags")


@pulumi.output_type
class CarrierGatewayTag(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClientVpnEndpointCertificateAuthenticationRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientRootCertificateChainArn":
            suggest = "client_root_certificate_chain_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClientVpnEndpointCertificateAuthenticationRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClientVpnEndpointCertificateAuthenticationRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClientVpnEndpointCertificateAuthenticationRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_root_certificate_chain_arn: str):
        pulumi.set(__self__, "client_root_certificate_chain_arn", client_root_certificate_chain_arn)

    @property
    @pulumi.getter(name="clientRootCertificateChainArn")
    def client_root_certificate_chain_arn(self) -> str:
        return pulumi.get(self, "client_root_certificate_chain_arn")


@pulumi.output_type
class ClientVpnEndpointClientAuthenticationRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activeDirectory":
            suggest = "active_directory"
        elif key == "federatedAuthentication":
            suggest = "federated_authentication"
        elif key == "mutualAuthentication":
            suggest = "mutual_authentication"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClientVpnEndpointClientAuthenticationRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClientVpnEndpointClientAuthenticationRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClientVpnEndpointClientAuthenticationRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 active_directory: Optional['outputs.ClientVpnEndpointDirectoryServiceAuthenticationRequest'] = None,
                 federated_authentication: Optional['outputs.ClientVpnEndpointFederatedAuthenticationRequest'] = None,
                 mutual_authentication: Optional['outputs.ClientVpnEndpointCertificateAuthenticationRequest'] = None):
        pulumi.set(__self__, "type", type)
        if active_directory is not None:
            pulumi.set(__self__, "active_directory", active_directory)
        if federated_authentication is not None:
            pulumi.set(__self__, "federated_authentication", federated_authentication)
        if mutual_authentication is not None:
            pulumi.set(__self__, "mutual_authentication", mutual_authentication)

    @property
    @pulumi.getter
    def type(self) -> str:
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="activeDirectory")
    def active_directory(self) -> Optional['outputs.ClientVpnEndpointDirectoryServiceAuthenticationRequest']:
        return pulumi.get(self, "active_directory")

    @property
    @pulumi.getter(name="federatedAuthentication")
    def federated_authentication(self) -> Optional['outputs.ClientVpnEndpointFederatedAuthenticationRequest']:
        return pulumi.get(self, "federated_authentication")

    @property
    @pulumi.getter(name="mutualAuthentication")
    def mutual_authentication(self) -> Optional['outputs.ClientVpnEndpointCertificateAuthenticationRequest']:
        return pulumi.get(self, "mutual_authentication")


@pulumi.output_type
class ClientVpnEndpointClientConnectOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lambdaFunctionArn":
            suggest = "lambda_function_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClientVpnEndpointClientConnectOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClientVpnEndpointClientConnectOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClientVpnEndpointClientConnectOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: bool,
                 lambda_function_arn: Optional[str] = None):
        pulumi.set(__self__, "enabled", enabled)
        if lambda_function_arn is not None:
            pulumi.set(__self__, "lambda_function_arn", lambda_function_arn)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="lambdaFunctionArn")
    def lambda_function_arn(self) -> Optional[str]:
        return pulumi.get(self, "lambda_function_arn")


@pulumi.output_type
class ClientVpnEndpointConnectionLogOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudwatchLogGroup":
            suggest = "cloudwatch_log_group"
        elif key == "cloudwatchLogStream":
            suggest = "cloudwatch_log_stream"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClientVpnEndpointConnectionLogOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClientVpnEndpointConnectionLogOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClientVpnEndpointConnectionLogOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: bool,
                 cloudwatch_log_group: Optional[str] = None,
                 cloudwatch_log_stream: Optional[str] = None):
        pulumi.set(__self__, "enabled", enabled)
        if cloudwatch_log_group is not None:
            pulumi.set(__self__, "cloudwatch_log_group", cloudwatch_log_group)
        if cloudwatch_log_stream is not None:
            pulumi.set(__self__, "cloudwatch_log_stream", cloudwatch_log_stream)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="cloudwatchLogGroup")
    def cloudwatch_log_group(self) -> Optional[str]:
        return pulumi.get(self, "cloudwatch_log_group")

    @property
    @pulumi.getter(name="cloudwatchLogStream")
    def cloudwatch_log_stream(self) -> Optional[str]:
        return pulumi.get(self, "cloudwatch_log_stream")


@pulumi.output_type
class ClientVpnEndpointDirectoryServiceAuthenticationRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "directoryId":
            suggest = "directory_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClientVpnEndpointDirectoryServiceAuthenticationRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClientVpnEndpointDirectoryServiceAuthenticationRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClientVpnEndpointDirectoryServiceAuthenticationRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 directory_id: str):
        pulumi.set(__self__, "directory_id", directory_id)

    @property
    @pulumi.getter(name="directoryId")
    def directory_id(self) -> str:
        return pulumi.get(self, "directory_id")


@pulumi.output_type
class ClientVpnEndpointFederatedAuthenticationRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sAMLProviderArn":
            suggest = "s_aml_provider_arn"
        elif key == "selfServiceSAMLProviderArn":
            suggest = "self_service_saml_provider_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClientVpnEndpointFederatedAuthenticationRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClientVpnEndpointFederatedAuthenticationRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClientVpnEndpointFederatedAuthenticationRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 s_aml_provider_arn: str,
                 self_service_saml_provider_arn: Optional[str] = None):
        pulumi.set(__self__, "s_aml_provider_arn", s_aml_provider_arn)
        if self_service_saml_provider_arn is not None:
            pulumi.set(__self__, "self_service_saml_provider_arn", self_service_saml_provider_arn)

    @property
    @pulumi.getter(name="sAMLProviderArn")
    def s_aml_provider_arn(self) -> str:
        return pulumi.get(self, "s_aml_provider_arn")

    @property
    @pulumi.getter(name="selfServiceSAMLProviderArn")
    def self_service_saml_provider_arn(self) -> Optional[str]:
        return pulumi.get(self, "self_service_saml_provider_arn")


@pulumi.output_type
class ClientVpnEndpointTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClientVpnEndpointTagSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceType":
            suggest = "resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClientVpnEndpointTagSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClientVpnEndpointTagSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClientVpnEndpointTagSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_type: str,
                 tags: Sequence['outputs.ClientVpnEndpointTag']):
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.ClientVpnEndpointTag']:
        return pulumi.get(self, "tags")


@pulumi.output_type
class CustomerGatewayTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class DHCPOptionsTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class EC2FleetCapacityReservationOptionsRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "usageStrategy":
            suggest = "usage_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetCapacityReservationOptionsRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetCapacityReservationOptionsRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetCapacityReservationOptionsRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 usage_strategy: Optional['EC2FleetCapacityReservationOptionsRequestUsageStrategy'] = None):
        if usage_strategy is not None:
            pulumi.set(__self__, "usage_strategy", usage_strategy)

    @property
    @pulumi.getter(name="usageStrategy")
    def usage_strategy(self) -> Optional['EC2FleetCapacityReservationOptionsRequestUsageStrategy']:
        return pulumi.get(self, "usage_strategy")


@pulumi.output_type
class EC2FleetFleetLaunchTemplateConfigRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "launchTemplateSpecification":
            suggest = "launch_template_specification"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetFleetLaunchTemplateConfigRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetFleetLaunchTemplateConfigRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetFleetLaunchTemplateConfigRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 launch_template_specification: Optional['outputs.EC2FleetFleetLaunchTemplateSpecificationRequest'] = None,
                 overrides: Optional[Sequence['outputs.EC2FleetFleetLaunchTemplateOverridesRequest']] = None):
        if launch_template_specification is not None:
            pulumi.set(__self__, "launch_template_specification", launch_template_specification)
        if overrides is not None:
            pulumi.set(__self__, "overrides", overrides)

    @property
    @pulumi.getter(name="launchTemplateSpecification")
    def launch_template_specification(self) -> Optional['outputs.EC2FleetFleetLaunchTemplateSpecificationRequest']:
        return pulumi.get(self, "launch_template_specification")

    @property
    @pulumi.getter
    def overrides(self) -> Optional[Sequence['outputs.EC2FleetFleetLaunchTemplateOverridesRequest']]:
        return pulumi.get(self, "overrides")


@pulumi.output_type
class EC2FleetFleetLaunchTemplateOverridesRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "maxPrice":
            suggest = "max_price"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "weightedCapacity":
            suggest = "weighted_capacity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetFleetLaunchTemplateOverridesRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetFleetLaunchTemplateOverridesRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetFleetLaunchTemplateOverridesRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 availability_zone: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 max_price: Optional[str] = None,
                 placement: Optional['outputs.EC2FleetPlacement'] = None,
                 priority: Optional[float] = None,
                 subnet_id: Optional[str] = None,
                 weighted_capacity: Optional[float] = None):
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if max_price is not None:
            pulumi.set(__self__, "max_price", max_price)
        if placement is not None:
            pulumi.set(__self__, "placement", placement)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[str]:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="maxPrice")
    def max_price(self) -> Optional[str]:
        return pulumi.get(self, "max_price")

    @property
    @pulumi.getter
    def placement(self) -> Optional['outputs.EC2FleetPlacement']:
        return pulumi.get(self, "placement")

    @property
    @pulumi.getter
    def priority(self) -> Optional[float]:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="weightedCapacity")
    def weighted_capacity(self) -> Optional[float]:
        return pulumi.get(self, "weighted_capacity")


@pulumi.output_type
class EC2FleetFleetLaunchTemplateSpecificationRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "launchTemplateId":
            suggest = "launch_template_id"
        elif key == "launchTemplateName":
            suggest = "launch_template_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetFleetLaunchTemplateSpecificationRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetFleetLaunchTemplateSpecificationRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetFleetLaunchTemplateSpecificationRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 launch_template_id: Optional[str] = None,
                 launch_template_name: Optional[str] = None,
                 version: Optional[str] = None):
        if launch_template_id is not None:
            pulumi.set(__self__, "launch_template_id", launch_template_id)
        if launch_template_name is not None:
            pulumi.set(__self__, "launch_template_name", launch_template_name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="launchTemplateId")
    def launch_template_id(self) -> Optional[str]:
        return pulumi.get(self, "launch_template_id")

    @property
    @pulumi.getter(name="launchTemplateName")
    def launch_template_name(self) -> Optional[str]:
        return pulumi.get(self, "launch_template_name")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        return pulumi.get(self, "version")


@pulumi.output_type
class EC2FleetOnDemandOptionsRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allocationStrategy":
            suggest = "allocation_strategy"
        elif key == "capacityReservationOptions":
            suggest = "capacity_reservation_options"
        elif key == "maxTotalPrice":
            suggest = "max_total_price"
        elif key == "minTargetCapacity":
            suggest = "min_target_capacity"
        elif key == "singleAvailabilityZone":
            suggest = "single_availability_zone"
        elif key == "singleInstanceType":
            suggest = "single_instance_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetOnDemandOptionsRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetOnDemandOptionsRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetOnDemandOptionsRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allocation_strategy: Optional[str] = None,
                 capacity_reservation_options: Optional['outputs.EC2FleetCapacityReservationOptionsRequest'] = None,
                 max_total_price: Optional[str] = None,
                 min_target_capacity: Optional[int] = None,
                 single_availability_zone: Optional[bool] = None,
                 single_instance_type: Optional[bool] = None):
        if allocation_strategy is not None:
            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
        if capacity_reservation_options is not None:
            pulumi.set(__self__, "capacity_reservation_options", capacity_reservation_options)
        if max_total_price is not None:
            pulumi.set(__self__, "max_total_price", max_total_price)
        if min_target_capacity is not None:
            pulumi.set(__self__, "min_target_capacity", min_target_capacity)
        if single_availability_zone is not None:
            pulumi.set(__self__, "single_availability_zone", single_availability_zone)
        if single_instance_type is not None:
            pulumi.set(__self__, "single_instance_type", single_instance_type)

    @property
    @pulumi.getter(name="allocationStrategy")
    def allocation_strategy(self) -> Optional[str]:
        return pulumi.get(self, "allocation_strategy")

    @property
    @pulumi.getter(name="capacityReservationOptions")
    def capacity_reservation_options(self) -> Optional['outputs.EC2FleetCapacityReservationOptionsRequest']:
        return pulumi.get(self, "capacity_reservation_options")

    @property
    @pulumi.getter(name="maxTotalPrice")
    def max_total_price(self) -> Optional[str]:
        return pulumi.get(self, "max_total_price")

    @property
    @pulumi.getter(name="minTargetCapacity")
    def min_target_capacity(self) -> Optional[int]:
        return pulumi.get(self, "min_target_capacity")

    @property
    @pulumi.getter(name="singleAvailabilityZone")
    def single_availability_zone(self) -> Optional[bool]:
        return pulumi.get(self, "single_availability_zone")

    @property
    @pulumi.getter(name="singleInstanceType")
    def single_instance_type(self) -> Optional[bool]:
        return pulumi.get(self, "single_instance_type")


@pulumi.output_type
class EC2FleetPlacement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "groupName":
            suggest = "group_name"
        elif key == "hostId":
            suggest = "host_id"
        elif key == "hostResourceGroupArn":
            suggest = "host_resource_group_arn"
        elif key == "partitionNumber":
            suggest = "partition_number"
        elif key == "spreadDomain":
            suggest = "spread_domain"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetPlacement. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetPlacement.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetPlacement.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 affinity: Optional[str] = None,
                 availability_zone: Optional[str] = None,
                 group_name: Optional[str] = None,
                 host_id: Optional[str] = None,
                 host_resource_group_arn: Optional[str] = None,
                 partition_number: Optional[int] = None,
                 spread_domain: Optional[str] = None,
                 tenancy: Optional[str] = None):
        if affinity is not None:
            pulumi.set(__self__, "affinity", affinity)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if group_name is not None:
            pulumi.set(__self__, "group_name", group_name)
        if host_id is not None:
            pulumi.set(__self__, "host_id", host_id)
        if host_resource_group_arn is not None:
            pulumi.set(__self__, "host_resource_group_arn", host_resource_group_arn)
        if partition_number is not None:
            pulumi.set(__self__, "partition_number", partition_number)
        if spread_domain is not None:
            pulumi.set(__self__, "spread_domain", spread_domain)
        if tenancy is not None:
            pulumi.set(__self__, "tenancy", tenancy)

    @property
    @pulumi.getter
    def affinity(self) -> Optional[str]:
        return pulumi.get(self, "affinity")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[str]:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="groupName")
    def group_name(self) -> Optional[str]:
        return pulumi.get(self, "group_name")

    @property
    @pulumi.getter(name="hostId")
    def host_id(self) -> Optional[str]:
        return pulumi.get(self, "host_id")

    @property
    @pulumi.getter(name="hostResourceGroupArn")
    def host_resource_group_arn(self) -> Optional[str]:
        return pulumi.get(self, "host_resource_group_arn")

    @property
    @pulumi.getter(name="partitionNumber")
    def partition_number(self) -> Optional[int]:
        return pulumi.get(self, "partition_number")

    @property
    @pulumi.getter(name="spreadDomain")
    def spread_domain(self) -> Optional[str]:
        return pulumi.get(self, "spread_domain")

    @property
    @pulumi.getter
    def tenancy(self) -> Optional[str]:
        return pulumi.get(self, "tenancy")


@pulumi.output_type
class EC2FleetSpotOptionsRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allocationStrategy":
            suggest = "allocation_strategy"
        elif key == "instanceInterruptionBehavior":
            suggest = "instance_interruption_behavior"
        elif key == "instancePoolsToUseCount":
            suggest = "instance_pools_to_use_count"
        elif key == "maxTotalPrice":
            suggest = "max_total_price"
        elif key == "minTargetCapacity":
            suggest = "min_target_capacity"
        elif key == "singleAvailabilityZone":
            suggest = "single_availability_zone"
        elif key == "singleInstanceType":
            suggest = "single_instance_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetSpotOptionsRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetSpotOptionsRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetSpotOptionsRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allocation_strategy: Optional['EC2FleetSpotOptionsRequestAllocationStrategy'] = None,
                 instance_interruption_behavior: Optional['EC2FleetSpotOptionsRequestInstanceInterruptionBehavior'] = None,
                 instance_pools_to_use_count: Optional[int] = None,
                 max_total_price: Optional[str] = None,
                 min_target_capacity: Optional[int] = None,
                 single_availability_zone: Optional[bool] = None,
                 single_instance_type: Optional[bool] = None):
        if allocation_strategy is not None:
            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
        if instance_interruption_behavior is not None:
            pulumi.set(__self__, "instance_interruption_behavior", instance_interruption_behavior)
        if instance_pools_to_use_count is not None:
            pulumi.set(__self__, "instance_pools_to_use_count", instance_pools_to_use_count)
        if max_total_price is not None:
            pulumi.set(__self__, "max_total_price", max_total_price)
        if min_target_capacity is not None:
            pulumi.set(__self__, "min_target_capacity", min_target_capacity)
        if single_availability_zone is not None:
            pulumi.set(__self__, "single_availability_zone", single_availability_zone)
        if single_instance_type is not None:
            pulumi.set(__self__, "single_instance_type", single_instance_type)

    @property
    @pulumi.getter(name="allocationStrategy")
    def allocation_strategy(self) -> Optional['EC2FleetSpotOptionsRequestAllocationStrategy']:
        return pulumi.get(self, "allocation_strategy")

    @property
    @pulumi.getter(name="instanceInterruptionBehavior")
    def instance_interruption_behavior(self) -> Optional['EC2FleetSpotOptionsRequestInstanceInterruptionBehavior']:
        return pulumi.get(self, "instance_interruption_behavior")

    @property
    @pulumi.getter(name="instancePoolsToUseCount")
    def instance_pools_to_use_count(self) -> Optional[int]:
        return pulumi.get(self, "instance_pools_to_use_count")

    @property
    @pulumi.getter(name="maxTotalPrice")
    def max_total_price(self) -> Optional[str]:
        return pulumi.get(self, "max_total_price")

    @property
    @pulumi.getter(name="minTargetCapacity")
    def min_target_capacity(self) -> Optional[int]:
        return pulumi.get(self, "min_target_capacity")

    @property
    @pulumi.getter(name="singleAvailabilityZone")
    def single_availability_zone(self) -> Optional[bool]:
        return pulumi.get(self, "single_availability_zone")

    @property
    @pulumi.getter(name="singleInstanceType")
    def single_instance_type(self) -> Optional[bool]:
        return pulumi.get(self, "single_instance_type")


@pulumi.output_type
class EC2FleetTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class EC2FleetTagSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceType":
            suggest = "resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetTagSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetTagSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetTagSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_type: Optional['EC2FleetTagSpecificationResourceType'] = None,
                 tags: Optional[Sequence['outputs.EC2FleetTag']] = None):
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional['EC2FleetTagSpecificationResourceType']:
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence['outputs.EC2FleetTag']]:
        return pulumi.get(self, "tags")


@pulumi.output_type
class EC2FleetTargetCapacitySpecificationRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "totalTargetCapacity":
            suggest = "total_target_capacity"
        elif key == "defaultTargetCapacityType":
            suggest = "default_target_capacity_type"
        elif key == "onDemandTargetCapacity":
            suggest = "on_demand_target_capacity"
        elif key == "spotTargetCapacity":
            suggest = "spot_target_capacity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EC2FleetTargetCapacitySpecificationRequest. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EC2FleetTargetCapacitySpecificationRequest.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EC2FleetTargetCapacitySpecificationRequest.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 total_target_capacity: int,
                 default_target_capacity_type: Optional['EC2FleetTargetCapacitySpecificationRequestDefaultTargetCapacityType'] = None,
                 on_demand_target_capacity: Optional[int] = None,
                 spot_target_capacity: Optional[int] = None):
        pulumi.set(__self__, "total_target_capacity", total_target_capacity)
        if default_target_capacity_type is not None:
            pulumi.set(__self__, "default_target_capacity_type", default_target_capacity_type)
        if on_demand_target_capacity is not None:
            pulumi.set(__self__, "on_demand_target_capacity", on_demand_target_capacity)
        if spot_target_capacity is not None:
            pulumi.set(__self__, "spot_target_capacity", spot_target_capacity)

    @property
    @pulumi.getter(name="totalTargetCapacity")
    def total_target_capacity(self) -> int:
        return pulumi.get(self, "total_target_capacity")

    @property
    @pulumi.getter(name="defaultTargetCapacityType")
    def default_target_capacity_type(self) -> Optional['EC2FleetTargetCapacitySpecificationRequestDefaultTargetCapacityType']:
        return pulumi.get(self, "default_target_capacity_type")

    @property
    @pulumi.getter(name="onDemandTargetCapacity")
    def on_demand_target_capacity(self) -> Optional[int]:
        return pulumi.get(self, "on_demand_target_capacity")

    @property
    @pulumi.getter(name="spotTargetCapacity")
    def spot_target_capacity(self) -> Optional[int]:
        return pulumi.get(self, "spot_target_capacity")


@pulumi.output_type
class EIPTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class FlowLogTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class InstanceAssociationParameter(dict):
    def __init__(__self__, *,
                 key: str,
                 value: Sequence[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Sequence[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class InstanceBlockDeviceMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "noDevice":
            suggest = "no_device"
        elif key == "virtualName":
            suggest = "virtual_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceBlockDeviceMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceBlockDeviceMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceBlockDeviceMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: str,
                 ebs: Optional['outputs.InstanceEbs'] = None,
                 no_device: Optional['outputs.InstanceNoDevice'] = None,
                 virtual_name: Optional[str] = None):
        pulumi.set(__self__, "device_name", device_name)
        if ebs is not None:
            pulumi.set(__self__, "ebs", ebs)
        if no_device is not None:
            pulumi.set(__self__, "no_device", no_device)
        if virtual_name is not None:
            pulumi.set(__self__, "virtual_name", virtual_name)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> str:
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter
    def ebs(self) -> Optional['outputs.InstanceEbs']:
        return pulumi.get(self, "ebs")

    @property
    @pulumi.getter(name="noDevice")
    def no_device(self) -> Optional['outputs.InstanceNoDevice']:
        return pulumi.get(self, "no_device")

    @property
    @pulumi.getter(name="virtualName")
    def virtual_name(self) -> Optional[str]:
        return pulumi.get(self, "virtual_name")


@pulumi.output_type
class InstanceCpuOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "coreCount":
            suggest = "core_count"
        elif key == "threadsPerCore":
            suggest = "threads_per_core"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceCpuOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceCpuOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceCpuOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 core_count: Optional[int] = None,
                 threads_per_core: Optional[int] = None):
        if core_count is not None:
            pulumi.set(__self__, "core_count", core_count)
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="coreCount")
    def core_count(self) -> Optional[int]:
        return pulumi.get(self, "core_count")

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[int]:
        return pulumi.get(self, "threads_per_core")


@pulumi.output_type
class InstanceCreditSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cPUCredits":
            suggest = "c_pu_credits"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceCreditSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceCreditSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceCreditSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 c_pu_credits: Optional[str] = None):
        if c_pu_credits is not None:
            pulumi.set(__self__, "c_pu_credits", c_pu_credits)

    @property
    @pulumi.getter(name="cPUCredits")
    def c_pu_credits(self) -> Optional[str]:
        return pulumi.get(self, "c_pu_credits")


@pulumi.output_type
class InstanceEbs(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteOnTermination":
            suggest = "delete_on_termination"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"
        elif key == "snapshotId":
            suggest = "snapshot_id"
        elif key == "volumeSize":
            suggest = "volume_size"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceEbs. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceEbs.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceEbs.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_on_termination: Optional[bool] = None,
                 encrypted: Optional[bool] = None,
                 iops: Optional[int] = None,
                 kms_key_id: Optional[str] = None,
                 snapshot_id: Optional[str] = None,
                 volume_size: Optional[int] = None,
                 volume_type: Optional[str] = None):
        if delete_on_termination is not None:
            pulumi.set(__self__, "delete_on_termination", delete_on_termination)
        if encrypted is not None:
            pulumi.set(__self__, "encrypted", encrypted)
        if iops is not None:
            pulumi.set(__self__, "iops", iops)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="deleteOnTermination")
    def delete_on_termination(self) -> Optional[bool]:
        return pulumi.get(self, "delete_on_termination")

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[bool]:
        return pulumi.get(self, "encrypted")

    @property
    @pulumi.getter
    def iops(self) -> Optional[int]:
        return pulumi.get(self, "iops")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[str]:
        return pulumi.get(self, "kms_key_id")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        return pulumi.get(self, "snapshot_id")

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[int]:
        return pulumi.get(self, "volume_size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[str]:
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class InstanceElasticGpuSpecification(dict):
    def __init__(__self__, *,
                 type: str):
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> str:
        return pulumi.get(self, "type")


@pulumi.output_type
class InstanceElasticInferenceAccelerator(dict):
    def __init__(__self__, *,
                 type: str,
                 count: Optional[int] = None):
        pulumi.set(__self__, "type", type)
        if count is not None:
            pulumi.set(__self__, "count", count)

    @property
    @pulumi.getter
    def type(self) -> str:
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        return pulumi.get(self, "count")


@pulumi.output_type
class InstanceEnclaveOptions(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class InstanceHibernationOptions(dict):
    def __init__(__self__, *,
                 configured: Optional[bool] = None):
        if configured is not None:
            pulumi.set(__self__, "configured", configured)

    @property
    @pulumi.getter
    def configured(self) -> Optional[bool]:
        return pulumi.get(self, "configured")


@pulumi.output_type
class InstanceInstanceIpv6Address(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipv6Address":
            suggest = "ipv6_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceInstanceIpv6Address. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceInstanceIpv6Address.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceInstanceIpv6Address.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ipv6_address: str):
        pulumi.set(__self__, "ipv6_address", ipv6_address)

    @property
    @pulumi.getter(name="ipv6Address")
    def ipv6_address(self) -> str:
        return pulumi.get(self, "ipv6_address")


@pulumi.output_type
class InstanceLaunchTemplateSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "launchTemplateId":
            suggest = "launch_template_id"
        elif key == "launchTemplateName":
            suggest = "launch_template_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceLaunchTemplateSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceLaunchTemplateSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceLaunchTemplateSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 version: str,
                 launch_template_id: Optional[str] = None,
                 launch_template_name: Optional[str] = None):
        pulumi.set(__self__, "version", version)
        if launch_template_id is not None:
            pulumi.set(__self__, "launch_template_id", launch_template_id)
        if launch_template_name is not None:
            pulumi.set(__self__, "launch_template_name", launch_template_name)

    @property
    @pulumi.getter
    def version(self) -> str:
        return pulumi.get(self, "version")

    @property
    @pulumi.getter(name="launchTemplateId")
    def launch_template_id(self) -> Optional[str]:
        return pulumi.get(self, "launch_template_id")

    @property
    @pulumi.getter(name="launchTemplateName")
    def launch_template_name(self) -> Optional[str]:
        return pulumi.get(self, "launch_template_name")


@pulumi.output_type
class InstanceLicenseSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "licenseConfigurationArn":
            suggest = "license_configuration_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceLicenseSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceLicenseSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceLicenseSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 license_configuration_arn: str):
        pulumi.set(__self__, "license_configuration_arn", license_configuration_arn)

    @property
    @pulumi.getter(name="licenseConfigurationArn")
    def license_configuration_arn(self) -> str:
        return pulumi.get(self, "license_configuration_arn")


@pulumi.output_type
class InstanceNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceIndex":
            suggest = "device_index"
        elif key == "associatePublicIpAddress":
            suggest = "associate_public_ip_address"
        elif key == "deleteOnTermination":
            suggest = "delete_on_termination"
        elif key == "groupSet":
            suggest = "group_set"
        elif key == "ipv6AddressCount":
            suggest = "ipv6_address_count"
        elif key == "ipv6Addresses":
            suggest = "ipv6_addresses"
        elif key == "networkInterfaceId":
            suggest = "network_interface_id"
        elif key == "privateIpAddress":
            suggest = "private_ip_address"
        elif key == "privateIpAddresses":
            suggest = "private_ip_addresses"
        elif key == "secondaryPrivateIpAddressCount":
            suggest = "secondary_private_ip_address_count"
        elif key == "subnetId":
            suggest = "subnet_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_index: str,
                 associate_public_ip_address: Optional[bool] = None,
                 delete_on_termination: Optional[bool] = None,
                 description: Optional[str] = None,
                 group_set: Optional[Sequence[str]] = None,
                 ipv6_address_count: Optional[int] = None,
                 ipv6_addresses: Optional[Sequence['outputs.InstanceInstanceIpv6Address']] = None,
                 network_interface_id: Optional[str] = None,
                 private_ip_address: Optional[str] = None,
                 private_ip_addresses: Optional[Sequence['outputs.InstancePrivateIpAddressSpecification']] = None,
                 secondary_private_ip_address_count: Optional[int] = None,
                 subnet_id: Optional[str] = None):
        pulumi.set(__self__, "device_index", device_index)
        if associate_public_ip_address is not None:
            pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
        if delete_on_termination is not None:
            pulumi.set(__self__, "delete_on_termination", delete_on_termination)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if group_set is not None:
            pulumi.set(__self__, "group_set", group_set)
        if ipv6_address_count is not None:
            pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        if ipv6_addresses is not None:
            pulumi.set(__self__, "ipv6_addresses", ipv6_addresses)
        if network_interface_id is not None:
            pulumi.set(__self__, "network_interface_id", network_interface_id)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if private_ip_addresses is not None:
            pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        if secondary_private_ip_address_count is not None:
            pulumi.set(__self__, "secondary_private_ip_address_count", secondary_private_ip_address_count)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="deviceIndex")
    def device_index(self) -> str:
        return pulumi.get(self, "device_index")

    @property
    @pulumi.getter(name="associatePublicIpAddress")
    def associate_public_ip_address(self) -> Optional[bool]:
        return pulumi.get(self, "associate_public_ip_address")

    @property
    @pulumi.getter(name="deleteOnTermination")
    def delete_on_termination(self) -> Optional[bool]:
        return pulumi.get(self, "delete_on_termination")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="groupSet")
    def group_set(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "group_set")

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> Optional[int]:
        return pulumi.get(self, "ipv6_address_count")

    @property
    @pulumi.getter(name="ipv6Addresses")
    def ipv6_addresses(self) -> Optional[Sequence['outputs.InstanceInstanceIpv6Address']]:
        return pulumi.get(self, "ipv6_addresses")

    @property
    @pulumi.getter(name="networkInterfaceId")
    def network_interface_id(self) -> Optional[str]:
        return pulumi.get(self, "network_interface_id")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Optional[Sequence['outputs.InstancePrivateIpAddressSpecification']]:
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="secondaryPrivateIpAddressCount")
    def secondary_private_ip_address_count(self) -> Optional[int]:
        return pulumi.get(self, "secondary_private_ip_address_count")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class InstanceNoDevice(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class InstancePrivateIpAddressSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateIpAddress":
            suggest = "private_ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstancePrivateIpAddressSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstancePrivateIpAddressSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstancePrivateIpAddressSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 primary: bool,
                 private_ip_address: str):
        pulumi.set(__self__, "primary", primary)
        pulumi.set(__self__, "private_ip_address", private_ip_address)

    @property
    @pulumi.getter
    def primary(self) -> bool:
        return pulumi.get(self, "primary")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> str:
        return pulumi.get(self, "private_ip_address")


@pulumi.output_type
class InstanceSsmAssociation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentName":
            suggest = "document_name"
        elif key == "associationParameters":
            suggest = "association_parameters"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceSsmAssociation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceSsmAssociation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceSsmAssociation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_name: str,
                 association_parameters: Optional[Sequence['outputs.InstanceAssociationParameter']] = None):
        pulumi.set(__self__, "document_name", document_name)
        if association_parameters is not None:
            pulumi.set(__self__, "association_parameters", association_parameters)

    @property
    @pulumi.getter(name="documentName")
    def document_name(self) -> str:
        return pulumi.get(self, "document_name")

    @property
    @pulumi.getter(name="associationParameters")
    def association_parameters(self) -> Optional[Sequence['outputs.InstanceAssociationParameter']]:
        return pulumi.get(self, "association_parameters")


@pulumi.output_type
class InstanceTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class InstanceVolume(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "volumeId":
            suggest = "volume_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceVolume. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceVolume.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceVolume.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device: str,
                 volume_id: str):
        pulumi.set(__self__, "device", device)
        pulumi.set(__self__, "volume_id", volume_id)

    @property
    @pulumi.getter
    def device(self) -> str:
        return pulumi.get(self, "device")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> str:
        return pulumi.get(self, "volume_id")


@pulumi.output_type
class InternetGatewayTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class LaunchTemplateBlockDeviceMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "noDevice":
            suggest = "no_device"
        elif key == "virtualName":
            suggest = "virtual_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateBlockDeviceMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateBlockDeviceMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateBlockDeviceMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: Optional[str] = None,
                 ebs: Optional['outputs.LaunchTemplateEbs'] = None,
                 no_device: Optional[str] = None,
                 virtual_name: Optional[str] = None):
        if device_name is not None:
            pulumi.set(__self__, "device_name", device_name)
        if ebs is not None:
            pulumi.set(__self__, "ebs", ebs)
        if no_device is not None:
            pulumi.set(__self__, "no_device", no_device)
        if virtual_name is not None:
            pulumi.set(__self__, "virtual_name", virtual_name)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[str]:
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter
    def ebs(self) -> Optional['outputs.LaunchTemplateEbs']:
        return pulumi.get(self, "ebs")

    @property
    @pulumi.getter(name="noDevice")
    def no_device(self) -> Optional[str]:
        return pulumi.get(self, "no_device")

    @property
    @pulumi.getter(name="virtualName")
    def virtual_name(self) -> Optional[str]:
        return pulumi.get(self, "virtual_name")


@pulumi.output_type
class LaunchTemplateCapacityReservationSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "capacityReservationPreference":
            suggest = "capacity_reservation_preference"
        elif key == "capacityReservationTarget":
            suggest = "capacity_reservation_target"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateCapacityReservationSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateCapacityReservationSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateCapacityReservationSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 capacity_reservation_preference: Optional[str] = None,
                 capacity_reservation_target: Optional['outputs.LaunchTemplateCapacityReservationTarget'] = None):
        if capacity_reservation_preference is not None:
            pulumi.set(__self__, "capacity_reservation_preference", capacity_reservation_preference)
        if capacity_reservation_target is not None:
            pulumi.set(__self__, "capacity_reservation_target", capacity_reservation_target)

    @property
    @pulumi.getter(name="capacityReservationPreference")
    def capacity_reservation_preference(self) -> Optional[str]:
        return pulumi.get(self, "capacity_reservation_preference")

    @property
    @pulumi.getter(name="capacityReservationTarget")
    def capacity_reservation_target(self) -> Optional['outputs.LaunchTemplateCapacityReservationTarget']:
        return pulumi.get(self, "capacity_reservation_target")


@pulumi.output_type
class LaunchTemplateCapacityReservationTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "capacityReservationId":
            suggest = "capacity_reservation_id"
        elif key == "capacityReservationResourceGroupArn":
            suggest = "capacity_reservation_resource_group_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateCapacityReservationTarget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateCapacityReservationTarget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateCapacityReservationTarget.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 capacity_reservation_id: Optional[str] = None,
                 capacity_reservation_resource_group_arn: Optional[str] = None):
        if capacity_reservation_id is not None:
            pulumi.set(__self__, "capacity_reservation_id", capacity_reservation_id)
        if capacity_reservation_resource_group_arn is not None:
            pulumi.set(__self__, "capacity_reservation_resource_group_arn", capacity_reservation_resource_group_arn)

    @property
    @pulumi.getter(name="capacityReservationId")
    def capacity_reservation_id(self) -> Optional[str]:
        return pulumi.get(self, "capacity_reservation_id")

    @property
    @pulumi.getter(name="capacityReservationResourceGroupArn")
    def capacity_reservation_resource_group_arn(self) -> Optional[str]:
        return pulumi.get(self, "capacity_reservation_resource_group_arn")


@pulumi.output_type
class LaunchTemplateCpuOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "coreCount":
            suggest = "core_count"
        elif key == "threadsPerCore":
            suggest = "threads_per_core"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateCpuOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateCpuOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateCpuOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 core_count: Optional[int] = None,
                 threads_per_core: Optional[int] = None):
        if core_count is not None:
            pulumi.set(__self__, "core_count", core_count)
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="coreCount")
    def core_count(self) -> Optional[int]:
        return pulumi.get(self, "core_count")

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[int]:
        return pulumi.get(self, "threads_per_core")


@pulumi.output_type
class LaunchTemplateCreditSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuCredits":
            suggest = "cpu_credits"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateCreditSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateCreditSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateCreditSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cpu_credits: Optional[str] = None):
        if cpu_credits is not None:
            pulumi.set(__self__, "cpu_credits", cpu_credits)

    @property
    @pulumi.getter(name="cpuCredits")
    def cpu_credits(self) -> Optional[str]:
        return pulumi.get(self, "cpu_credits")


@pulumi.output_type
class LaunchTemplateEbs(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteOnTermination":
            suggest = "delete_on_termination"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"
        elif key == "snapshotId":
            suggest = "snapshot_id"
        elif key == "volumeSize":
            suggest = "volume_size"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateEbs. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateEbs.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateEbs.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_on_termination: Optional[bool] = None,
                 encrypted: Optional[bool] = None,
                 iops: Optional[int] = None,
                 kms_key_id: Optional[str] = None,
                 snapshot_id: Optional[str] = None,
                 throughput: Optional[int] = None,
                 volume_size: Optional[int] = None,
                 volume_type: Optional[str] = None):
        if delete_on_termination is not None:
            pulumi.set(__self__, "delete_on_termination", delete_on_termination)
        if encrypted is not None:
            pulumi.set(__self__, "encrypted", encrypted)
        if iops is not None:
            pulumi.set(__self__, "iops", iops)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)
        if throughput is not None:
            pulumi.set(__self__, "throughput", throughput)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="deleteOnTermination")
    def delete_on_termination(self) -> Optional[bool]:
        return pulumi.get(self, "delete_on_termination")

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[bool]:
        return pulumi.get(self, "encrypted")

    @property
    @pulumi.getter
    def iops(self) -> Optional[int]:
        return pulumi.get(self, "iops")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[str]:
        return pulumi.get(self, "kms_key_id")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        return pulumi.get(self, "snapshot_id")

    @property
    @pulumi.getter
    def throughput(self) -> Optional[int]:
        return pulumi.get(self, "throughput")

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[int]:
        return pulumi.get(self, "volume_size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[str]:
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class LaunchTemplateElasticGpuSpecification(dict):
    def __init__(__self__, *,
                 type: Optional[str] = None):
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        return pulumi.get(self, "type")


@pulumi.output_type
class LaunchTemplateEnclaveOptions(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class LaunchTemplateHibernationOptions(dict):
    def __init__(__self__, *,
                 configured: Optional[bool] = None):
        if configured is not None:
            pulumi.set(__self__, "configured", configured)

    @property
    @pulumi.getter
    def configured(self) -> Optional[bool]:
        return pulumi.get(self, "configured")


@pulumi.output_type
class LaunchTemplateIamInstanceProfile(dict):
    def __init__(__self__, *,
                 arn: Optional[str] = None,
                 name: Optional[str] = None):
        if arn is not None:
            pulumi.set(__self__, "arn", arn)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def arn(self) -> Optional[str]:
        return pulumi.get(self, "arn")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        return pulumi.get(self, "name")


@pulumi.output_type
class LaunchTemplateInstanceMarketOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "marketType":
            suggest = "market_type"
        elif key == "spotOptions":
            suggest = "spot_options"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateInstanceMarketOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateInstanceMarketOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateInstanceMarketOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 market_type: Optional[str] = None,
                 spot_options: Optional['outputs.LaunchTemplateSpotOptions'] = None):
        if market_type is not None:
            pulumi.set(__self__, "market_type", market_type)
        if spot_options is not None:
            pulumi.set(__self__, "spot_options", spot_options)

    @property
    @pulumi.getter(name="marketType")
    def market_type(self) -> Optional[str]:
        return pulumi.get(self, "market_type")

    @property
    @pulumi.getter(name="spotOptions")
    def spot_options(self) -> Optional['outputs.LaunchTemplateSpotOptions']:
        return pulumi.get(self, "spot_options")


@pulumi.output_type
class LaunchTemplateIpv6Add(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipv6Address":
            suggest = "ipv6_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateIpv6Add. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateIpv6Add.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateIpv6Add.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ipv6_address: Optional[str] = None):
        if ipv6_address is not None:
            pulumi.set(__self__, "ipv6_address", ipv6_address)

    @property
    @pulumi.getter(name="ipv6Address")
    def ipv6_address(self) -> Optional[str]:
        return pulumi.get(self, "ipv6_address")


@pulumi.output_type
class LaunchTemplateLaunchTemplateData(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blockDeviceMappings":
            suggest = "block_device_mappings"
        elif key == "capacityReservationSpecification":
            suggest = "capacity_reservation_specification"
        elif key == "cpuOptions":
            suggest = "cpu_options"
        elif key == "creditSpecification":
            suggest = "credit_specification"
        elif key == "disableApiTermination":
            suggest = "disable_api_termination"
        elif key == "ebsOptimized":
            suggest = "ebs_optimized"
        elif key == "elasticGpuSpecifications":
            suggest = "elastic_gpu_specifications"
        elif key == "elasticInferenceAccelerators":
            suggest = "elastic_inference_accelerators"
        elif key == "enclaveOptions":
            suggest = "enclave_options"
        elif key == "hibernationOptions":
            suggest = "hibernation_options"
        elif key == "iamInstanceProfile":
            suggest = "iam_instance_profile"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "instanceInitiatedShutdownBehavior":
            suggest = "instance_initiated_shutdown_behavior"
        elif key == "instanceMarketOptions":
            suggest = "instance_market_options"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "kernelId":
            suggest = "kernel_id"
        elif key == "keyName":
            suggest = "key_name"
        elif key == "licenseSpecifications":
            suggest = "license_specifications"
        elif key == "metadataOptions":
            suggest = "metadata_options"
        elif key == "networkInterfaces":
            suggest = "network_interfaces"
        elif key == "ramDiskId":
            suggest = "ram_disk_id"
        elif key == "securityGroupIds":
            suggest = "security_group_ids"
        elif key == "securityGroups":
            suggest = "security_groups"
        elif key == "tagSpecifications":
            suggest = "tag_specifications"
        elif key == "userData":
            suggest = "user_data"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateLaunchTemplateData. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateLaunchTemplateData.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateLaunchTemplateData.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 block_device_mappings: Optional[Sequence['outputs.LaunchTemplateBlockDeviceMapping']] = None,
                 capacity_reservation_specification: Optional['outputs.LaunchTemplateCapacityReservationSpecification'] = None,
                 cpu_options: Optional['outputs.LaunchTemplateCpuOptions'] = None,
                 credit_specification: Optional['outputs.LaunchTemplateCreditSpecification'] = None,
                 disable_api_termination: Optional[bool] = None,
                 ebs_optimized: Optional[bool] = None,
                 elastic_gpu_specifications: Optional[Sequence['outputs.LaunchTemplateElasticGpuSpecification']] = None,
                 elastic_inference_accelerators: Optional[Sequence['outputs.LaunchTemplateLaunchTemplateElasticInferenceAccelerator']] = None,
                 enclave_options: Optional['outputs.LaunchTemplateEnclaveOptions'] = None,
                 hibernation_options: Optional['outputs.LaunchTemplateHibernationOptions'] = None,
                 iam_instance_profile: Optional['outputs.LaunchTemplateIamInstanceProfile'] = None,
                 image_id: Optional[str] = None,
                 instance_initiated_shutdown_behavior: Optional[str] = None,
                 instance_market_options: Optional['outputs.LaunchTemplateInstanceMarketOptions'] = None,
                 instance_type: Optional[str] = None,
                 kernel_id: Optional[str] = None,
                 key_name: Optional[str] = None,
                 license_specifications: Optional[Sequence['outputs.LaunchTemplateLicenseSpecification']] = None,
                 metadata_options: Optional['outputs.LaunchTemplateMetadataOptions'] = None,
                 monitoring: Optional['outputs.LaunchTemplateMonitoring'] = None,
                 network_interfaces: Optional[Sequence['outputs.LaunchTemplateNetworkInterface']] = None,
                 placement: Optional['outputs.LaunchTemplatePlacement'] = None,
                 ram_disk_id: Optional[str] = None,
                 security_group_ids: Optional[Sequence[str]] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 tag_specifications: Optional[Sequence['outputs.LaunchTemplateTagSpecification']] = None,
                 user_data: Optional[str] = None):
        if block_device_mappings is not None:
            pulumi.set(__self__, "block_device_mappings", block_device_mappings)
        if capacity_reservation_specification is not None:
            pulumi.set(__self__, "capacity_reservation_specification", capacity_reservation_specification)
        if cpu_options is not None:
            pulumi.set(__self__, "cpu_options", cpu_options)
        if credit_specification is not None:
            pulumi.set(__self__, "credit_specification", credit_specification)
        if disable_api_termination is not None:
            pulumi.set(__self__, "disable_api_termination", disable_api_termination)
        if ebs_optimized is not None:
            pulumi.set(__self__, "ebs_optimized", ebs_optimized)
        if elastic_gpu_specifications is not None:
            pulumi.set(__self__, "elastic_gpu_specifications", elastic_gpu_specifications)
        if elastic_inference_accelerators is not None:
            pulumi.set(__self__, "elastic_inference_accelerators", elastic_inference_accelerators)
        if enclave_options is not None:
            pulumi.set(__self__, "enclave_options", enclave_options)
        if hibernation_options is not None:
            pulumi.set(__self__, "hibernation_options", hibernation_options)
        if iam_instance_profile is not None:
            pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if instance_initiated_shutdown_behavior is not None:
            pulumi.set(__self__, "instance_initiated_shutdown_behavior", instance_initiated_shutdown_behavior)
        if instance_market_options is not None:
            pulumi.set(__self__, "instance_market_options", instance_market_options)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if kernel_id is not None:
            pulumi.set(__self__, "kernel_id", kernel_id)
        if key_name is not None:
            pulumi.set(__self__, "key_name", key_name)
        if license_specifications is not None:
            pulumi.set(__self__, "license_specifications", license_specifications)
        if metadata_options is not None:
            pulumi.set(__self__, "metadata_options", metadata_options)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network_interfaces is not None:
            pulumi.set(__self__, "network_interfaces", network_interfaces)
        if placement is not None:
            pulumi.set(__self__, "placement", placement)
        if ram_disk_id is not None:
            pulumi.set(__self__, "ram_disk_id", ram_disk_id)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if tag_specifications is not None:
            pulumi.set(__self__, "tag_specifications", tag_specifications)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)

    @property
    @pulumi.getter(name="blockDeviceMappings")
    def block_device_mappings(self) -> Optional[Sequence['outputs.LaunchTemplateBlockDeviceMapping']]:
        return pulumi.get(self, "block_device_mappings")

    @property
    @pulumi.getter(name="capacityReservationSpecification")
    def capacity_reservation_specification(self) -> Optional['outputs.LaunchTemplateCapacityReservationSpecification']:
        return pulumi.get(self, "capacity_reservation_specification")

    @property
    @pulumi.getter(name="cpuOptions")
    def cpu_options(self) -> Optional['outputs.LaunchTemplateCpuOptions']:
        return pulumi.get(self, "cpu_options")

    @property
    @pulumi.getter(name="creditSpecification")
    def credit_specification(self) -> Optional['outputs.LaunchTemplateCreditSpecification']:
        return pulumi.get(self, "credit_specification")

    @property
    @pulumi.getter(name="disableApiTermination")
    def disable_api_termination(self) -> Optional[bool]:
        return pulumi.get(self, "disable_api_termination")

    @property
    @pulumi.getter(name="ebsOptimized")
    def ebs_optimized(self) -> Optional[bool]:
        return pulumi.get(self, "ebs_optimized")

    @property
    @pulumi.getter(name="elasticGpuSpecifications")
    def elastic_gpu_specifications(self) -> Optional[Sequence['outputs.LaunchTemplateElasticGpuSpecification']]:
        return pulumi.get(self, "elastic_gpu_specifications")

    @property
    @pulumi.getter(name="elasticInferenceAccelerators")
    def elastic_inference_accelerators(self) -> Optional[Sequence['outputs.LaunchTemplateLaunchTemplateElasticInferenceAccelerator']]:
        return pulumi.get(self, "elastic_inference_accelerators")

    @property
    @pulumi.getter(name="enclaveOptions")
    def enclave_options(self) -> Optional['outputs.LaunchTemplateEnclaveOptions']:
        return pulumi.get(self, "enclave_options")

    @property
    @pulumi.getter(name="hibernationOptions")
    def hibernation_options(self) -> Optional['outputs.LaunchTemplateHibernationOptions']:
        return pulumi.get(self, "hibernation_options")

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional['outputs.LaunchTemplateIamInstanceProfile']:
        return pulumi.get(self, "iam_instance_profile")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceInitiatedShutdownBehavior")
    def instance_initiated_shutdown_behavior(self) -> Optional[str]:
        return pulumi.get(self, "instance_initiated_shutdown_behavior")

    @property
    @pulumi.getter(name="instanceMarketOptions")
    def instance_market_options(self) -> Optional['outputs.LaunchTemplateInstanceMarketOptions']:
        return pulumi.get(self, "instance_market_options")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="kernelId")
    def kernel_id(self) -> Optional[str]:
        return pulumi.get(self, "kernel_id")

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> Optional[str]:
        return pulumi.get(self, "key_name")

    @property
    @pulumi.getter(name="licenseSpecifications")
    def license_specifications(self) -> Optional[Sequence['outputs.LaunchTemplateLicenseSpecification']]:
        return pulumi.get(self, "license_specifications")

    @property
    @pulumi.getter(name="metadataOptions")
    def metadata_options(self) -> Optional['outputs.LaunchTemplateMetadataOptions']:
        return pulumi.get(self, "metadata_options")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional['outputs.LaunchTemplateMonitoring']:
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="networkInterfaces")
    def network_interfaces(self) -> Optional[Sequence['outputs.LaunchTemplateNetworkInterface']]:
        return pulumi.get(self, "network_interfaces")

    @property
    @pulumi.getter
    def placement(self) -> Optional['outputs.LaunchTemplatePlacement']:
        return pulumi.get(self, "placement")

    @property
    @pulumi.getter(name="ramDiskId")
    def ram_disk_id(self) -> Optional[str]:
        return pulumi.get(self, "ram_disk_id")

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "security_group_ids")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="tagSpecifications")
    def tag_specifications(self) -> Optional[Sequence['outputs.LaunchTemplateTagSpecification']]:
        return pulumi.get(self, "tag_specifications")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[str]:
        return pulumi.get(self, "user_data")


@pulumi.output_type
class LaunchTemplateLaunchTemplateElasticInferenceAccelerator(dict):
    def __init__(__self__, *,
                 count: Optional[int] = None,
                 type: Optional[str] = None):
        if count is not None:
            pulumi.set(__self__, "count", count)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        return pulumi.get(self, "type")


@pulumi.output_type
class LaunchTemplateLaunchTemplateTagSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceType":
            suggest = "resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateLaunchTemplateTagSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateLaunchTemplateTagSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateLaunchTemplateTagSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_type: Optional[str] = None,
                 tags: Optional[Sequence['outputs.LaunchTemplateTag']] = None):
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence['outputs.LaunchTemplateTag']]:
        return pulumi.get(self, "tags")


@pulumi.output_type
class LaunchTemplateLicenseSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "licenseConfigurationArn":
            suggest = "license_configuration_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateLicenseSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateLicenseSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateLicenseSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 license_configuration_arn: Optional[str] = None):
        if license_configuration_arn is not None:
            pulumi.set(__self__, "license_configuration_arn", license_configuration_arn)

    @property
    @pulumi.getter(name="licenseConfigurationArn")
    def license_configuration_arn(self) -> Optional[str]:
        return pulumi.get(self, "license_configuration_arn")


@pulumi.output_type
class LaunchTemplateMetadataOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpEndpoint":
            suggest = "http_endpoint"
        elif key == "httpPutResponseHopLimit":
            suggest = "http_put_response_hop_limit"
        elif key == "httpTokens":
            suggest = "http_tokens"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateMetadataOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateMetadataOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateMetadataOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 http_endpoint: Optional[str] = None,
                 http_put_response_hop_limit: Optional[int] = None,
                 http_tokens: Optional[str] = None):
        if http_endpoint is not None:
            pulumi.set(__self__, "http_endpoint", http_endpoint)
        if http_put_response_hop_limit is not None:
            pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
        if http_tokens is not None:
            pulumi.set(__self__, "http_tokens", http_tokens)

    @property
    @pulumi.getter(name="httpEndpoint")
    def http_endpoint(self) -> Optional[str]:
        return pulumi.get(self, "http_endpoint")

    @property
    @pulumi.getter(name="httpPutResponseHopLimit")
    def http_put_response_hop_limit(self) -> Optional[int]:
        return pulumi.get(self, "http_put_response_hop_limit")

    @property
    @pulumi.getter(name="httpTokens")
    def http_tokens(self) -> Optional[str]:
        return pulumi.get(self, "http_tokens")


@pulumi.output_type
class LaunchTemplateMonitoring(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class LaunchTemplateNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "associateCarrierIpAddress":
            suggest = "associate_carrier_ip_address"
        elif key == "associatePublicIpAddress":
            suggest = "associate_public_ip_address"
        elif key == "deleteOnTermination":
            suggest = "delete_on_termination"
        elif key == "deviceIndex":
            suggest = "device_index"
        elif key == "interfaceType":
            suggest = "interface_type"
        elif key == "ipv6AddressCount":
            suggest = "ipv6_address_count"
        elif key == "ipv6Addresses":
            suggest = "ipv6_addresses"
        elif key == "networkCardIndex":
            suggest = "network_card_index"
        elif key == "networkInterfaceId":
            suggest = "network_interface_id"
        elif key == "privateIpAddress":
            suggest = "private_ip_address"
        elif key == "privateIpAddresses":
            suggest = "private_ip_addresses"
        elif key == "secondaryPrivateIpAddressCount":
            suggest = "secondary_private_ip_address_count"
        elif key == "subnetId":
            suggest = "subnet_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 associate_carrier_ip_address: Optional[bool] = None,
                 associate_public_ip_address: Optional[bool] = None,
                 delete_on_termination: Optional[bool] = None,
                 description: Optional[str] = None,
                 device_index: Optional[int] = None,
                 groups: Optional[Sequence[str]] = None,
                 interface_type: Optional[str] = None,
                 ipv6_address_count: Optional[int] = None,
                 ipv6_addresses: Optional[Sequence['outputs.LaunchTemplateIpv6Add']] = None,
                 network_card_index: Optional[int] = None,
                 network_interface_id: Optional[str] = None,
                 private_ip_address: Optional[str] = None,
                 private_ip_addresses: Optional[Sequence['outputs.LaunchTemplatePrivateIpAdd']] = None,
                 secondary_private_ip_address_count: Optional[int] = None,
                 subnet_id: Optional[str] = None):
        if associate_carrier_ip_address is not None:
            pulumi.set(__self__, "associate_carrier_ip_address", associate_carrier_ip_address)
        if associate_public_ip_address is not None:
            pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
        if delete_on_termination is not None:
            pulumi.set(__self__, "delete_on_termination", delete_on_termination)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if device_index is not None:
            pulumi.set(__self__, "device_index", device_index)
        if groups is not None:
            pulumi.set(__self__, "groups", groups)
        if interface_type is not None:
            pulumi.set(__self__, "interface_type", interface_type)
        if ipv6_address_count is not None:
            pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        if ipv6_addresses is not None:
            pulumi.set(__self__, "ipv6_addresses", ipv6_addresses)
        if network_card_index is not None:
            pulumi.set(__self__, "network_card_index", network_card_index)
        if network_interface_id is not None:
            pulumi.set(__self__, "network_interface_id", network_interface_id)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if private_ip_addresses is not None:
            pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        if secondary_private_ip_address_count is not None:
            pulumi.set(__self__, "secondary_private_ip_address_count", secondary_private_ip_address_count)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="associateCarrierIpAddress")
    def associate_carrier_ip_address(self) -> Optional[bool]:
        return pulumi.get(self, "associate_carrier_ip_address")

    @property
    @pulumi.getter(name="associatePublicIpAddress")
    def associate_public_ip_address(self) -> Optional[bool]:
        return pulumi.get(self, "associate_public_ip_address")

    @property
    @pulumi.getter(name="deleteOnTermination")
    def delete_on_termination(self) -> Optional[bool]:
        return pulumi.get(self, "delete_on_termination")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="deviceIndex")
    def device_index(self) -> Optional[int]:
        return pulumi.get(self, "device_index")

    @property
    @pulumi.getter
    def groups(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "groups")

    @property
    @pulumi.getter(name="interfaceType")
    def interface_type(self) -> Optional[str]:
        return pulumi.get(self, "interface_type")

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> Optional[int]:
        return pulumi.get(self, "ipv6_address_count")

    @property
    @pulumi.getter(name="ipv6Addresses")
    def ipv6_addresses(self) -> Optional[Sequence['outputs.LaunchTemplateIpv6Add']]:
        return pulumi.get(self, "ipv6_addresses")

    @property
    @pulumi.getter(name="networkCardIndex")
    def network_card_index(self) -> Optional[int]:
        return pulumi.get(self, "network_card_index")

    @property
    @pulumi.getter(name="networkInterfaceId")
    def network_interface_id(self) -> Optional[str]:
        return pulumi.get(self, "network_interface_id")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Optional[Sequence['outputs.LaunchTemplatePrivateIpAdd']]:
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="secondaryPrivateIpAddressCount")
    def secondary_private_ip_address_count(self) -> Optional[int]:
        return pulumi.get(self, "secondary_private_ip_address_count")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class LaunchTemplatePlacement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "groupName":
            suggest = "group_name"
        elif key == "hostId":
            suggest = "host_id"
        elif key == "hostResourceGroupArn":
            suggest = "host_resource_group_arn"
        elif key == "partitionNumber":
            suggest = "partition_number"
        elif key == "spreadDomain":
            suggest = "spread_domain"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplatePlacement. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplatePlacement.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplatePlacement.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 affinity: Optional[str] = None,
                 availability_zone: Optional[str] = None,
                 group_name: Optional[str] = None,
                 host_id: Optional[str] = None,
                 host_resource_group_arn: Optional[str] = None,
                 partition_number: Optional[int] = None,
                 spread_domain: Optional[str] = None,
                 tenancy: Optional[str] = None):
        if affinity is not None:
            pulumi.set(__self__, "affinity", affinity)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if group_name is not None:
            pulumi.set(__self__, "group_name", group_name)
        if host_id is not None:
            pulumi.set(__self__, "host_id", host_id)
        if host_resource_group_arn is not None:
            pulumi.set(__self__, "host_resource_group_arn", host_resource_group_arn)
        if partition_number is not None:
            pulumi.set(__self__, "partition_number", partition_number)
        if spread_domain is not None:
            pulumi.set(__self__, "spread_domain", spread_domain)
        if tenancy is not None:
            pulumi.set(__self__, "tenancy", tenancy)

    @property
    @pulumi.getter
    def affinity(self) -> Optional[str]:
        return pulumi.get(self, "affinity")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[str]:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="groupName")
    def group_name(self) -> Optional[str]:
        return pulumi.get(self, "group_name")

    @property
    @pulumi.getter(name="hostId")
    def host_id(self) -> Optional[str]:
        return pulumi.get(self, "host_id")

    @property
    @pulumi.getter(name="hostResourceGroupArn")
    def host_resource_group_arn(self) -> Optional[str]:
        return pulumi.get(self, "host_resource_group_arn")

    @property
    @pulumi.getter(name="partitionNumber")
    def partition_number(self) -> Optional[int]:
        return pulumi.get(self, "partition_number")

    @property
    @pulumi.getter(name="spreadDomain")
    def spread_domain(self) -> Optional[str]:
        return pulumi.get(self, "spread_domain")

    @property
    @pulumi.getter
    def tenancy(self) -> Optional[str]:
        return pulumi.get(self, "tenancy")


@pulumi.output_type
class LaunchTemplatePrivateIpAdd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateIpAddress":
            suggest = "private_ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplatePrivateIpAdd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplatePrivateIpAdd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplatePrivateIpAdd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 primary: Optional[bool] = None,
                 private_ip_address: Optional[str] = None):
        if primary is not None:
            pulumi.set(__self__, "primary", primary)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)

    @property
    @pulumi.getter
    def primary(self) -> Optional[bool]:
        return pulumi.get(self, "primary")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        return pulumi.get(self, "private_ip_address")


@pulumi.output_type
class LaunchTemplateSpotOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blockDurationMinutes":
            suggest = "block_duration_minutes"
        elif key == "instanceInterruptionBehavior":
            suggest = "instance_interruption_behavior"
        elif key == "maxPrice":
            suggest = "max_price"
        elif key == "spotInstanceType":
            suggest = "spot_instance_type"
        elif key == "validUntil":
            suggest = "valid_until"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateSpotOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateSpotOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateSpotOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 block_duration_minutes: Optional[int] = None,
                 instance_interruption_behavior: Optional[str] = None,
                 max_price: Optional[str] = None,
                 spot_instance_type: Optional[str] = None,
                 valid_until: Optional[str] = None):
        if block_duration_minutes is not None:
            pulumi.set(__self__, "block_duration_minutes", block_duration_minutes)
        if instance_interruption_behavior is not None:
            pulumi.set(__self__, "instance_interruption_behavior", instance_interruption_behavior)
        if max_price is not None:
            pulumi.set(__self__, "max_price", max_price)
        if spot_instance_type is not None:
            pulumi.set(__self__, "spot_instance_type", spot_instance_type)
        if valid_until is not None:
            pulumi.set(__self__, "valid_until", valid_until)

    @property
    @pulumi.getter(name="blockDurationMinutes")
    def block_duration_minutes(self) -> Optional[int]:
        return pulumi.get(self, "block_duration_minutes")

    @property
    @pulumi.getter(name="instanceInterruptionBehavior")
    def instance_interruption_behavior(self) -> Optional[str]:
        return pulumi.get(self, "instance_interruption_behavior")

    @property
    @pulumi.getter(name="maxPrice")
    def max_price(self) -> Optional[str]:
        return pulumi.get(self, "max_price")

    @property
    @pulumi.getter(name="spotInstanceType")
    def spot_instance_type(self) -> Optional[str]:
        return pulumi.get(self, "spot_instance_type")

    @property
    @pulumi.getter(name="validUntil")
    def valid_until(self) -> Optional[str]:
        return pulumi.get(self, "valid_until")


@pulumi.output_type
class LaunchTemplateTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class LaunchTemplateTagSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceType":
            suggest = "resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LaunchTemplateTagSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LaunchTemplateTagSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LaunchTemplateTagSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_type: Optional[str] = None,
                 tags: Optional[Sequence['outputs.LaunchTemplateTag']] = None):
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence['outputs.LaunchTemplateTag']]:
        return pulumi.get(self, "tags")


@pulumi.output_type
class LocalGatewayRouteTableVPCAssociationTag(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class NatGatewayTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class NetworkAclEntryIcmp(dict):
    def __init__(__self__, *,
                 code: Optional[int] = None,
                 type: Optional[int] = None):
        if code is not None:
            pulumi.set(__self__, "code", code)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def code(self) -> Optional[int]:
        return pulumi.get(self, "code")

    @property
    @pulumi.getter
    def type(self) -> Optional[int]:
        return pulumi.get(self, "type")


@pulumi.output_type
class NetworkAclEntryPortRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "from":
            suggest = "from_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkAclEntryPortRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkAclEntryPortRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkAclEntryPortRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 from_: Optional[int] = None,
                 to: Optional[int] = None):
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if to is not None:
            pulumi.set(__self__, "to", to)

    @property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[int]:
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter
    def to(self) -> Optional[int]:
        return pulumi.get(self, "to")


@pulumi.output_type
class NetworkAclTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class NetworkInsightsAnalysisAlternatePathHint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "componentArn":
            suggest = "component_arn"
        elif key == "componentId":
            suggest = "component_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisAlternatePathHint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisAlternatePathHint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisAlternatePathHint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 component_arn: Optional[str] = None,
                 component_id: Optional[str] = None):
        if component_arn is not None:
            pulumi.set(__self__, "component_arn", component_arn)
        if component_id is not None:
            pulumi.set(__self__, "component_id", component_id)

    @property
    @pulumi.getter(name="componentArn")
    def component_arn(self) -> Optional[str]:
        return pulumi.get(self, "component_arn")

    @property
    @pulumi.getter(name="componentId")
    def component_id(self) -> Optional[str]:
        return pulumi.get(self, "component_id")


@pulumi.output_type
class NetworkInsightsAnalysisAnalysisAclRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portRange":
            suggest = "port_range"
        elif key == "ruleAction":
            suggest = "rule_action"
        elif key == "ruleNumber":
            suggest = "rule_number"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisAnalysisAclRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisAnalysisAclRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisAnalysisAclRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cidr: Optional[str] = None,
                 egress: Optional[bool] = None,
                 port_range: Optional['outputs.NetworkInsightsAnalysisPortRange'] = None,
                 protocol: Optional[str] = None,
                 rule_action: Optional[str] = None,
                 rule_number: Optional[int] = None):
        if cidr is not None:
            pulumi.set(__self__, "cidr", cidr)
        if egress is not None:
            pulumi.set(__self__, "egress", egress)
        if port_range is not None:
            pulumi.set(__self__, "port_range", port_range)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if rule_action is not None:
            pulumi.set(__self__, "rule_action", rule_action)
        if rule_number is not None:
            pulumi.set(__self__, "rule_number", rule_number)

    @property
    @pulumi.getter
    def cidr(self) -> Optional[str]:
        return pulumi.get(self, "cidr")

    @property
    @pulumi.getter
    def egress(self) -> Optional[bool]:
        return pulumi.get(self, "egress")

    @property
    @pulumi.getter(name="portRange")
    def port_range(self) -> Optional['outputs.NetworkInsightsAnalysisPortRange']:
        return pulumi.get(self, "port_range")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="ruleAction")
    def rule_action(self) -> Optional[str]:
        return pulumi.get(self, "rule_action")

    @property
    @pulumi.getter(name="ruleNumber")
    def rule_number(self) -> Optional[int]:
        return pulumi.get(self, "rule_number")


@pulumi.output_type
class NetworkInsightsAnalysisAnalysisComponent(dict):
    def __init__(__self__, *,
                 arn: Optional[str] = None,
                 id: Optional[str] = None):
        if arn is not None:
            pulumi.set(__self__, "arn", arn)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def arn(self) -> Optional[str]:
        return pulumi.get(self, "arn")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkInsightsAnalysisAnalysisLoadBalancerListener(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instancePort":
            suggest = "instance_port"
        elif key == "loadBalancerPort":
            suggest = "load_balancer_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisAnalysisLoadBalancerListener. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisAnalysisLoadBalancerListener.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisAnalysisLoadBalancerListener.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_port: Optional[int] = None,
                 load_balancer_port: Optional[int] = None):
        if instance_port is not None:
            pulumi.set(__self__, "instance_port", instance_port)
        if load_balancer_port is not None:
            pulumi.set(__self__, "load_balancer_port", load_balancer_port)

    @property
    @pulumi.getter(name="instancePort")
    def instance_port(self) -> Optional[int]:
        return pulumi.get(self, "instance_port")

    @property
    @pulumi.getter(name="loadBalancerPort")
    def load_balancer_port(self) -> Optional[int]:
        return pulumi.get(self, "load_balancer_port")


@pulumi.output_type
class NetworkInsightsAnalysisAnalysisLoadBalancerTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZone":
            suggest = "availability_zone"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisAnalysisLoadBalancerTarget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisAnalysisLoadBalancerTarget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisAnalysisLoadBalancerTarget.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[str] = None,
                 availability_zone: Optional[str] = None,
                 instance: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 port: Optional[int] = None):
        if address is not None:
            pulumi.set(__self__, "address", address)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if instance is not None:
            pulumi.set(__self__, "instance", instance)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[str]:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter
    def instance(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "instance")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        return pulumi.get(self, "port")


@pulumi.output_type
class NetworkInsightsAnalysisAnalysisPacketHeader(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationAddresses":
            suggest = "destination_addresses"
        elif key == "destinationPortRanges":
            suggest = "destination_port_ranges"
        elif key == "sourceAddresses":
            suggest = "source_addresses"
        elif key == "sourcePortRanges":
            suggest = "source_port_ranges"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisAnalysisPacketHeader. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisAnalysisPacketHeader.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisAnalysisPacketHeader.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 destination_addresses: Optional[Sequence[str]] = None,
                 destination_port_ranges: Optional[Sequence['outputs.NetworkInsightsAnalysisPortRange']] = None,
                 protocol: Optional[str] = None,
                 source_addresses: Optional[Sequence[str]] = None,
                 source_port_ranges: Optional[Sequence['outputs.NetworkInsightsAnalysisPortRange']] = None):
        if destination_addresses is not None:
            pulumi.set(__self__, "destination_addresses", destination_addresses)
        if destination_port_ranges is not None:
            pulumi.set(__self__, "destination_port_ranges", destination_port_ranges)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if source_addresses is not None:
            pulumi.set(__self__, "source_addresses", source_addresses)
        if source_port_ranges is not None:
            pulumi.set(__self__, "source_port_ranges", source_port_ranges)

    @property
    @pulumi.getter(name="destinationAddresses")
    def destination_addresses(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "destination_addresses")

    @property
    @pulumi.getter(name="destinationPortRanges")
    def destination_port_ranges(self) -> Optional[Sequence['outputs.NetworkInsightsAnalysisPortRange']]:
        return pulumi.get(self, "destination_port_ranges")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="sourceAddresses")
    def source_addresses(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "source_addresses")

    @property
    @pulumi.getter(name="sourcePortRanges")
    def source_port_ranges(self) -> Optional[Sequence['outputs.NetworkInsightsAnalysisPortRange']]:
        return pulumi.get(self, "source_port_ranges")


@pulumi.output_type
class NetworkInsightsAnalysisAnalysisRouteTableRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationCidr":
            suggest = "destination_cidr"
        elif key == "destinationPrefixListId":
            suggest = "destination_prefix_list_id"
        elif key == "egressOnlyInternetGatewayId":
            suggest = "egress_only_internet_gateway_id"
        elif key == "gatewayId":
            suggest = "gateway_id"
        elif key == "instanceId":
            suggest = "instance_id"
        elif key == "natGatewayId":
            suggest = "nat_gateway_id"
        elif key == "networkInterfaceId":
            suggest = "network_interface_id"
        elif key == "transitGatewayId":
            suggest = "transit_gateway_id"
        elif key == "vpcPeeringConnectionId":
            suggest = "vpc_peering_connection_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisAnalysisRouteTableRoute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisAnalysisRouteTableRoute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisAnalysisRouteTableRoute.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 destination_cidr: Optional[str] = None,
                 destination_prefix_list_id: Optional[str] = None,
                 egress_only_internet_gateway_id: Optional[str] = None,
                 gateway_id: Optional[str] = None,
                 instance_id: Optional[str] = None,
                 nat_gateway_id: Optional[str] = None,
                 network_interface_id: Optional[str] = None,
                 origin: Optional[str] = None,
                 transit_gateway_id: Optional[str] = None,
                 vpc_peering_connection_id: Optional[str] = None):
        if destination_cidr is not None:
            pulumi.set(__self__, "destination_cidr", destination_cidr)
        if destination_prefix_list_id is not None:
            pulumi.set(__self__, "destination_prefix_list_id", destination_prefix_list_id)
        if egress_only_internet_gateway_id is not None:
            pulumi.set(__self__, "egress_only_internet_gateway_id", egress_only_internet_gateway_id)
        if gateway_id is not None:
            pulumi.set(__self__, "gateway_id", gateway_id)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if nat_gateway_id is not None:
            pulumi.set(__self__, "nat_gateway_id", nat_gateway_id)
        if network_interface_id is not None:
            pulumi.set(__self__, "network_interface_id", network_interface_id)
        if origin is not None:
            pulumi.set(__self__, "origin", origin)
        if transit_gateway_id is not None:
            pulumi.set(__self__, "transit_gateway_id", transit_gateway_id)
        if vpc_peering_connection_id is not None:
            pulumi.set(__self__, "vpc_peering_connection_id", vpc_peering_connection_id)

    @property
    @pulumi.getter(name="destinationCidr")
    def destination_cidr(self) -> Optional[str]:
        return pulumi.get(self, "destination_cidr")

    @property
    @pulumi.getter(name="destinationPrefixListId")
    def destination_prefix_list_id(self) -> Optional[str]:
        return pulumi.get(self, "destination_prefix_list_id")

    @property
    @pulumi.getter(name="egressOnlyInternetGatewayId")
    def egress_only_internet_gateway_id(self) -> Optional[str]:
        return pulumi.get(self, "egress_only_internet_gateway_id")

    @property
    @pulumi.getter(name="gatewayId")
    def gateway_id(self) -> Optional[str]:
        return pulumi.get(self, "gateway_id")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[str]:
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="natGatewayId")
    def nat_gateway_id(self) -> Optional[str]:
        return pulumi.get(self, "nat_gateway_id")

    @property
    @pulumi.getter(name="networkInterfaceId")
    def network_interface_id(self) -> Optional[str]:
        return pulumi.get(self, "network_interface_id")

    @property
    @pulumi.getter
    def origin(self) -> Optional[str]:
        return pulumi.get(self, "origin")

    @property
    @pulumi.getter(name="transitGatewayId")
    def transit_gateway_id(self) -> Optional[str]:
        return pulumi.get(self, "transit_gateway_id")

    @property
    @pulumi.getter(name="vpcPeeringConnectionId")
    def vpc_peering_connection_id(self) -> Optional[str]:
        return pulumi.get(self, "vpc_peering_connection_id")


@pulumi.output_type
class NetworkInsightsAnalysisAnalysisSecurityGroupRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portRange":
            suggest = "port_range"
        elif key == "prefixListId":
            suggest = "prefix_list_id"
        elif key == "securityGroupId":
            suggest = "security_group_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisAnalysisSecurityGroupRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisAnalysisSecurityGroupRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisAnalysisSecurityGroupRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cidr: Optional[str] = None,
                 direction: Optional[str] = None,
                 port_range: Optional['outputs.NetworkInsightsAnalysisPortRange'] = None,
                 prefix_list_id: Optional[str] = None,
                 protocol: Optional[str] = None,
                 security_group_id: Optional[str] = None):
        if cidr is not None:
            pulumi.set(__self__, "cidr", cidr)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)
        if port_range is not None:
            pulumi.set(__self__, "port_range", port_range)
        if prefix_list_id is not None:
            pulumi.set(__self__, "prefix_list_id", prefix_list_id)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if security_group_id is not None:
            pulumi.set(__self__, "security_group_id", security_group_id)

    @property
    @pulumi.getter
    def cidr(self) -> Optional[str]:
        return pulumi.get(self, "cidr")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter(name="portRange")
    def port_range(self) -> Optional['outputs.NetworkInsightsAnalysisPortRange']:
        return pulumi.get(self, "port_range")

    @property
    @pulumi.getter(name="prefixListId")
    def prefix_list_id(self) -> Optional[str]:
        return pulumi.get(self, "prefix_list_id")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> Optional[str]:
        return pulumi.get(self, "security_group_id")


@pulumi.output_type
class NetworkInsightsAnalysisExplanation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aclRule":
            suggest = "acl_rule"
        elif key == "attachedTo":
            suggest = "attached_to"
        elif key == "availabilityZones":
            suggest = "availability_zones"
        elif key == "classicLoadBalancerListener":
            suggest = "classic_load_balancer_listener"
        elif key == "customerGateway":
            suggest = "customer_gateway"
        elif key == "destinationVpc":
            suggest = "destination_vpc"
        elif key == "elasticLoadBalancerListener":
            suggest = "elastic_load_balancer_listener"
        elif key == "explanationCode":
            suggest = "explanation_code"
        elif key == "ingressRouteTable":
            suggest = "ingress_route_table"
        elif key == "internetGateway":
            suggest = "internet_gateway"
        elif key == "loadBalancerArn":
            suggest = "load_balancer_arn"
        elif key == "loadBalancerListenerPort":
            suggest = "load_balancer_listener_port"
        elif key == "loadBalancerTarget":
            suggest = "load_balancer_target"
        elif key == "loadBalancerTargetGroup":
            suggest = "load_balancer_target_group"
        elif key == "loadBalancerTargetGroups":
            suggest = "load_balancer_target_groups"
        elif key == "loadBalancerTargetPort":
            suggest = "load_balancer_target_port"
        elif key == "missingComponent":
            suggest = "missing_component"
        elif key == "natGateway":
            suggest = "nat_gateway"
        elif key == "networkInterface":
            suggest = "network_interface"
        elif key == "packetField":
            suggest = "packet_field"
        elif key == "portRanges":
            suggest = "port_ranges"
        elif key == "prefixList":
            suggest = "prefix_list"
        elif key == "routeTable":
            suggest = "route_table"
        elif key == "routeTableRoute":
            suggest = "route_table_route"
        elif key == "securityGroup":
            suggest = "security_group"
        elif key == "securityGroupRule":
            suggest = "security_group_rule"
        elif key == "securityGroups":
            suggest = "security_groups"
        elif key == "sourceVpc":
            suggest = "source_vpc"
        elif key == "subnetRouteTable":
            suggest = "subnet_route_table"
        elif key == "vpcEndpoint":
            suggest = "vpc_endpoint"
        elif key == "vpcPeeringConnection":
            suggest = "vpc_peering_connection"
        elif key == "vpnConnection":
            suggest = "vpn_connection"
        elif key == "vpnGateway":
            suggest = "vpn_gateway"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisExplanation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisExplanation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisExplanation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 acl: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 acl_rule: Optional['outputs.NetworkInsightsAnalysisAnalysisAclRule'] = None,
                 address: Optional[str] = None,
                 addresses: Optional[Sequence[str]] = None,
                 attached_to: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 availability_zones: Optional[Sequence[str]] = None,
                 cidrs: Optional[Sequence[str]] = None,
                 classic_load_balancer_listener: Optional['outputs.NetworkInsightsAnalysisAnalysisLoadBalancerListener'] = None,
                 component: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 customer_gateway: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 destination: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 destination_vpc: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 direction: Optional[str] = None,
                 elastic_load_balancer_listener: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 explanation_code: Optional[str] = None,
                 ingress_route_table: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 internet_gateway: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 load_balancer_arn: Optional[str] = None,
                 load_balancer_listener_port: Optional[int] = None,
                 load_balancer_target: Optional['outputs.NetworkInsightsAnalysisAnalysisLoadBalancerTarget'] = None,
                 load_balancer_target_group: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 load_balancer_target_groups: Optional[Sequence['outputs.NetworkInsightsAnalysisAnalysisComponent']] = None,
                 load_balancer_target_port: Optional[int] = None,
                 missing_component: Optional[str] = None,
                 nat_gateway: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 network_interface: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 packet_field: Optional[str] = None,
                 port: Optional[int] = None,
                 port_ranges: Optional[Sequence['outputs.NetworkInsightsAnalysisPortRange']] = None,
                 prefix_list: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 protocols: Optional[Sequence[str]] = None,
                 route_table: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 route_table_route: Optional['outputs.NetworkInsightsAnalysisAnalysisRouteTableRoute'] = None,
                 security_group: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 security_group_rule: Optional['outputs.NetworkInsightsAnalysisAnalysisSecurityGroupRule'] = None,
                 security_groups: Optional[Sequence['outputs.NetworkInsightsAnalysisAnalysisComponent']] = None,
                 source_vpc: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 state: Optional[str] = None,
                 subnet: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 subnet_route_table: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 vpc: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 vpc_endpoint: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 vpc_peering_connection: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 vpn_connection: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 vpn_gateway: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None):
        if acl is not None:
            pulumi.set(__self__, "acl", acl)
        if acl_rule is not None:
            pulumi.set(__self__, "acl_rule", acl_rule)
        if address is not None:
            pulumi.set(__self__, "address", address)
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)
        if attached_to is not None:
            pulumi.set(__self__, "attached_to", attached_to)
        if availability_zones is not None:
            pulumi.set(__self__, "availability_zones", availability_zones)
        if cidrs is not None:
            pulumi.set(__self__, "cidrs", cidrs)
        if classic_load_balancer_listener is not None:
            pulumi.set(__self__, "classic_load_balancer_listener", classic_load_balancer_listener)
        if component is not None:
            pulumi.set(__self__, "component", component)
        if customer_gateway is not None:
            pulumi.set(__self__, "customer_gateway", customer_gateway)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if destination_vpc is not None:
            pulumi.set(__self__, "destination_vpc", destination_vpc)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)
        if elastic_load_balancer_listener is not None:
            pulumi.set(__self__, "elastic_load_balancer_listener", elastic_load_balancer_listener)
        if explanation_code is not None:
            pulumi.set(__self__, "explanation_code", explanation_code)
        if ingress_route_table is not None:
            pulumi.set(__self__, "ingress_route_table", ingress_route_table)
        if internet_gateway is not None:
            pulumi.set(__self__, "internet_gateway", internet_gateway)
        if load_balancer_arn is not None:
            pulumi.set(__self__, "load_balancer_arn", load_balancer_arn)
        if load_balancer_listener_port is not None:
            pulumi.set(__self__, "load_balancer_listener_port", load_balancer_listener_port)
        if load_balancer_target is not None:
            pulumi.set(__self__, "load_balancer_target", load_balancer_target)
        if load_balancer_target_group is not None:
            pulumi.set(__self__, "load_balancer_target_group", load_balancer_target_group)
        if load_balancer_target_groups is not None:
            pulumi.set(__self__, "load_balancer_target_groups", load_balancer_target_groups)
        if load_balancer_target_port is not None:
            pulumi.set(__self__, "load_balancer_target_port", load_balancer_target_port)
        if missing_component is not None:
            pulumi.set(__self__, "missing_component", missing_component)
        if nat_gateway is not None:
            pulumi.set(__self__, "nat_gateway", nat_gateway)
        if network_interface is not None:
            pulumi.set(__self__, "network_interface", network_interface)
        if packet_field is not None:
            pulumi.set(__self__, "packet_field", packet_field)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if port_ranges is not None:
            pulumi.set(__self__, "port_ranges", port_ranges)
        if prefix_list is not None:
            pulumi.set(__self__, "prefix_list", prefix_list)
        if protocols is not None:
            pulumi.set(__self__, "protocols", protocols)
        if route_table is not None:
            pulumi.set(__self__, "route_table", route_table)
        if route_table_route is not None:
            pulumi.set(__self__, "route_table_route", route_table_route)
        if security_group is not None:
            pulumi.set(__self__, "security_group", security_group)
        if security_group_rule is not None:
            pulumi.set(__self__, "security_group_rule", security_group_rule)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if source_vpc is not None:
            pulumi.set(__self__, "source_vpc", source_vpc)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if subnet_route_table is not None:
            pulumi.set(__self__, "subnet_route_table", subnet_route_table)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)
        if vpc_endpoint is not None:
            pulumi.set(__self__, "vpc_endpoint", vpc_endpoint)
        if vpc_peering_connection is not None:
            pulumi.set(__self__, "vpc_peering_connection", vpc_peering_connection)
        if vpn_connection is not None:
            pulumi.set(__self__, "vpn_connection", vpn_connection)
        if vpn_gateway is not None:
            pulumi.set(__self__, "vpn_gateway", vpn_gateway)

    @property
    @pulumi.getter
    def acl(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "acl")

    @property
    @pulumi.getter(name="aclRule")
    def acl_rule(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisAclRule']:
        return pulumi.get(self, "acl_rule")

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "addresses")

    @property
    @pulumi.getter(name="attachedTo")
    def attached_to(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "attached_to")

    @property
    @pulumi.getter(name="availabilityZones")
    def availability_zones(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "availability_zones")

    @property
    @pulumi.getter
    def cidrs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "cidrs")

    @property
    @pulumi.getter(name="classicLoadBalancerListener")
    def classic_load_balancer_listener(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisLoadBalancerListener']:
        return pulumi.get(self, "classic_load_balancer_listener")

    @property
    @pulumi.getter
    def component(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "component")

    @property
    @pulumi.getter(name="customerGateway")
    def customer_gateway(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "customer_gateway")

    @property
    @pulumi.getter
    def destination(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "destination")

    @property
    @pulumi.getter(name="destinationVpc")
    def destination_vpc(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "destination_vpc")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter(name="elasticLoadBalancerListener")
    def elastic_load_balancer_listener(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "elastic_load_balancer_listener")

    @property
    @pulumi.getter(name="explanationCode")
    def explanation_code(self) -> Optional[str]:
        return pulumi.get(self, "explanation_code")

    @property
    @pulumi.getter(name="ingressRouteTable")
    def ingress_route_table(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "ingress_route_table")

    @property
    @pulumi.getter(name="internetGateway")
    def internet_gateway(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "internet_gateway")

    @property
    @pulumi.getter(name="loadBalancerArn")
    def load_balancer_arn(self) -> Optional[str]:
        return pulumi.get(self, "load_balancer_arn")

    @property
    @pulumi.getter(name="loadBalancerListenerPort")
    def load_balancer_listener_port(self) -> Optional[int]:
        return pulumi.get(self, "load_balancer_listener_port")

    @property
    @pulumi.getter(name="loadBalancerTarget")
    def load_balancer_target(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisLoadBalancerTarget']:
        return pulumi.get(self, "load_balancer_target")

    @property
    @pulumi.getter(name="loadBalancerTargetGroup")
    def load_balancer_target_group(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "load_balancer_target_group")

    @property
    @pulumi.getter(name="loadBalancerTargetGroups")
    def load_balancer_target_groups(self) -> Optional[Sequence['outputs.NetworkInsightsAnalysisAnalysisComponent']]:
        return pulumi.get(self, "load_balancer_target_groups")

    @property
    @pulumi.getter(name="loadBalancerTargetPort")
    def load_balancer_target_port(self) -> Optional[int]:
        return pulumi.get(self, "load_balancer_target_port")

    @property
    @pulumi.getter(name="missingComponent")
    def missing_component(self) -> Optional[str]:
        return pulumi.get(self, "missing_component")

    @property
    @pulumi.getter(name="natGateway")
    def nat_gateway(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "nat_gateway")

    @property
    @pulumi.getter(name="networkInterface")
    def network_interface(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "network_interface")

    @property
    @pulumi.getter(name="packetField")
    def packet_field(self) -> Optional[str]:
        return pulumi.get(self, "packet_field")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="portRanges")
    def port_ranges(self) -> Optional[Sequence['outputs.NetworkInsightsAnalysisPortRange']]:
        return pulumi.get(self, "port_ranges")

    @property
    @pulumi.getter(name="prefixList")
    def prefix_list(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "prefix_list")

    @property
    @pulumi.getter
    def protocols(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "protocols")

    @property
    @pulumi.getter(name="routeTable")
    def route_table(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "route_table")

    @property
    @pulumi.getter(name="routeTableRoute")
    def route_table_route(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisRouteTableRoute']:
        return pulumi.get(self, "route_table_route")

    @property
    @pulumi.getter(name="securityGroup")
    def security_group(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "security_group")

    @property
    @pulumi.getter(name="securityGroupRule")
    def security_group_rule(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisSecurityGroupRule']:
        return pulumi.get(self, "security_group_rule")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[Sequence['outputs.NetworkInsightsAnalysisAnalysisComponent']]:
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="sourceVpc")
    def source_vpc(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "source_vpc")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        return pulumi.get(self, "state")

    @property
    @pulumi.getter
    def subnet(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter(name="subnetRouteTable")
    def subnet_route_table(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "subnet_route_table")

    @property
    @pulumi.getter
    def vpc(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter(name="vpcEndpoint")
    def vpc_endpoint(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "vpc_endpoint")

    @property
    @pulumi.getter(name="vpcPeeringConnection")
    def vpc_peering_connection(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "vpc_peering_connection")

    @property
    @pulumi.getter(name="vpnConnection")
    def vpn_connection(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "vpn_connection")

    @property
    @pulumi.getter(name="vpnGateway")
    def vpn_gateway(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "vpn_gateway")


@pulumi.output_type
class NetworkInsightsAnalysisPathComponent(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aclRule":
            suggest = "acl_rule"
        elif key == "destinationVpc":
            suggest = "destination_vpc"
        elif key == "inboundHeader":
            suggest = "inbound_header"
        elif key == "outboundHeader":
            suggest = "outbound_header"
        elif key == "routeTableRoute":
            suggest = "route_table_route"
        elif key == "securityGroupRule":
            suggest = "security_group_rule"
        elif key == "sequenceNumber":
            suggest = "sequence_number"
        elif key == "sourceVpc":
            suggest = "source_vpc"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisPathComponent. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisPathComponent.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisPathComponent.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 acl_rule: Optional['outputs.NetworkInsightsAnalysisAnalysisAclRule'] = None,
                 component: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 destination_vpc: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 inbound_header: Optional['outputs.NetworkInsightsAnalysisAnalysisPacketHeader'] = None,
                 outbound_header: Optional['outputs.NetworkInsightsAnalysisAnalysisPacketHeader'] = None,
                 route_table_route: Optional['outputs.NetworkInsightsAnalysisAnalysisRouteTableRoute'] = None,
                 security_group_rule: Optional['outputs.NetworkInsightsAnalysisAnalysisSecurityGroupRule'] = None,
                 sequence_number: Optional[int] = None,
                 source_vpc: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 subnet: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None,
                 vpc: Optional['outputs.NetworkInsightsAnalysisAnalysisComponent'] = None):
        if acl_rule is not None:
            pulumi.set(__self__, "acl_rule", acl_rule)
        if component is not None:
            pulumi.set(__self__, "component", component)
        if destination_vpc is not None:
            pulumi.set(__self__, "destination_vpc", destination_vpc)
        if inbound_header is not None:
            pulumi.set(__self__, "inbound_header", inbound_header)
        if outbound_header is not None:
            pulumi.set(__self__, "outbound_header", outbound_header)
        if route_table_route is not None:
            pulumi.set(__self__, "route_table_route", route_table_route)
        if security_group_rule is not None:
            pulumi.set(__self__, "security_group_rule", security_group_rule)
        if sequence_number is not None:
            pulumi.set(__self__, "sequence_number", sequence_number)
        if source_vpc is not None:
            pulumi.set(__self__, "source_vpc", source_vpc)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)

    @property
    @pulumi.getter(name="aclRule")
    def acl_rule(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisAclRule']:
        return pulumi.get(self, "acl_rule")

    @property
    @pulumi.getter
    def component(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "component")

    @property
    @pulumi.getter(name="destinationVpc")
    def destination_vpc(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "destination_vpc")

    @property
    @pulumi.getter(name="inboundHeader")
    def inbound_header(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisPacketHeader']:
        return pulumi.get(self, "inbound_header")

    @property
    @pulumi.getter(name="outboundHeader")
    def outbound_header(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisPacketHeader']:
        return pulumi.get(self, "outbound_header")

    @property
    @pulumi.getter(name="routeTableRoute")
    def route_table_route(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisRouteTableRoute']:
        return pulumi.get(self, "route_table_route")

    @property
    @pulumi.getter(name="securityGroupRule")
    def security_group_rule(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisSecurityGroupRule']:
        return pulumi.get(self, "security_group_rule")

    @property
    @pulumi.getter(name="sequenceNumber")
    def sequence_number(self) -> Optional[int]:
        return pulumi.get(self, "sequence_number")

    @property
    @pulumi.getter(name="sourceVpc")
    def source_vpc(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "source_vpc")

    @property
    @pulumi.getter
    def subnet(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter
    def vpc(self) -> Optional['outputs.NetworkInsightsAnalysisAnalysisComponent']:
        return pulumi.get(self, "vpc")


@pulumi.output_type
class NetworkInsightsAnalysisPortRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "from":
            suggest = "from_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInsightsAnalysisPortRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInsightsAnalysisPortRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInsightsAnalysisPortRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 from_: Optional[int] = None,
                 to: Optional[int] = None):
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if to is not None:
            pulumi.set(__self__, "to", to)

    @property
    @pulumi.getter(name="from")
    def from_(self) -> Optional[int]:
        return pulumi.get(self, "from_")

    @property
    @pulumi.getter
    def to(self) -> Optional[int]:
        return pulumi.get(self, "to")


@pulumi.output_type
class NetworkInsightsAnalysisTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class NetworkInsightsPathTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class NetworkInterfaceInstanceIpv6Address(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipv6Address":
            suggest = "ipv6_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInterfaceInstanceIpv6Address. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInterfaceInstanceIpv6Address.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInterfaceInstanceIpv6Address.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ipv6_address: str):
        pulumi.set(__self__, "ipv6_address", ipv6_address)

    @property
    @pulumi.getter(name="ipv6Address")
    def ipv6_address(self) -> str:
        return pulumi.get(self, "ipv6_address")


@pulumi.output_type
class NetworkInterfacePrivateIpAddressSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateIpAddress":
            suggest = "private_ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkInterfacePrivateIpAddressSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkInterfacePrivateIpAddressSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkInterfacePrivateIpAddressSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 primary: bool,
                 private_ip_address: str):
        pulumi.set(__self__, "primary", primary)
        pulumi.set(__self__, "private_ip_address", private_ip_address)

    @property
    @pulumi.getter
    def primary(self) -> bool:
        return pulumi.get(self, "primary")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> str:
        return pulumi.get(self, "private_ip_address")


@pulumi.output_type
class NetworkInterfaceTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class PrefixListEntry(dict):
    def __init__(__self__, *,
                 cidr: str,
                 description: Optional[str] = None):
        pulumi.set(__self__, "cidr", cidr)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def cidr(self) -> str:
        return pulumi.get(self, "cidr")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")


@pulumi.output_type
class PrefixListTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteTableTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class SecurityGroupEgress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipProtocol":
            suggest = "ip_protocol"
        elif key == "cidrIp":
            suggest = "cidr_ip"
        elif key == "cidrIpv6":
            suggest = "cidr_ipv6"
        elif key == "destinationPrefixListId":
            suggest = "destination_prefix_list_id"
        elif key == "destinationSecurityGroupId":
            suggest = "destination_security_group_id"
        elif key == "fromPort":
            suggest = "from_port"
        elif key == "toPort":
            suggest = "to_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityGroupEgress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityGroupEgress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityGroupEgress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_protocol: str,
                 cidr_ip: Optional[str] = None,
                 cidr_ipv6: Optional[str] = None,
                 description: Optional[str] = None,
                 destination_prefix_list_id: Optional[str] = None,
                 destination_security_group_id: Optional[str] = None,
                 from_port: Optional[int] = None,
                 to_port: Optional[int] = None):
        pulumi.set(__self__, "ip_protocol", ip_protocol)
        if cidr_ip is not None:
            pulumi.set(__self__, "cidr_ip", cidr_ip)
        if cidr_ipv6 is not None:
            pulumi.set(__self__, "cidr_ipv6", cidr_ipv6)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if destination_prefix_list_id is not None:
            pulumi.set(__self__, "destination_prefix_list_id", destination_prefix_list_id)
        if destination_security_group_id is not None:
            pulumi.set(__self__, "destination_security_group_id", destination_security_group_id)
        if from_port is not None:
            pulumi.set(__self__, "from_port", from_port)
        if to_port is not None:
            pulumi.set(__self__, "to_port", to_port)

    @property
    @pulumi.getter(name="ipProtocol")
    def ip_protocol(self) -> str:
        return pulumi.get(self, "ip_protocol")

    @property
    @pulumi.getter(name="cidrIp")
    def cidr_ip(self) -> Optional[str]:
        return pulumi.get(self, "cidr_ip")

    @property
    @pulumi.getter(name="cidrIpv6")
    def cidr_ipv6(self) -> Optional[str]:
        return pulumi.get(self, "cidr_ipv6")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="destinationPrefixListId")
    def destination_prefix_list_id(self) -> Optional[str]:
        return pulumi.get(self, "destination_prefix_list_id")

    @property
    @pulumi.getter(name="destinationSecurityGroupId")
    def destination_security_group_id(self) -> Optional[str]:
        return pulumi.get(self, "destination_security_group_id")

    @property
    @pulumi.getter(name="fromPort")
    def from_port(self) -> Optional[int]:
        return pulumi.get(self, "from_port")

    @property
    @pulumi.getter(name="toPort")
    def to_port(self) -> Optional[int]:
        return pulumi.get(self, "to_port")


@pulumi.output_type
class SecurityGroupIngress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipProtocol":
            suggest = "ip_protocol"
        elif key == "cidrIp":
            suggest = "cidr_ip"
        elif key == "cidrIpv6":
            suggest = "cidr_ipv6"
        elif key == "fromPort":
            suggest = "from_port"
        elif key == "sourcePrefixListId":
            suggest = "source_prefix_list_id"
        elif key == "sourceSecurityGroupId":
            suggest = "source_security_group_id"
        elif key == "sourceSecurityGroupName":
            suggest = "source_security_group_name"
        elif key == "sourceSecurityGroupOwnerId":
            suggest = "source_security_group_owner_id"
        elif key == "toPort":
            suggest = "to_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SecurityGroupIngress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SecurityGroupIngress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SecurityGroupIngress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_protocol: str,
                 cidr_ip: Optional[str] = None,
                 cidr_ipv6: Optional[str] = None,
                 description: Optional[str] = None,
                 from_port: Optional[int] = None,
                 source_prefix_list_id: Optional[str] = None,
                 source_security_group_id: Optional[str] = None,
                 source_security_group_name: Optional[str] = None,
                 source_security_group_owner_id: Optional[str] = None,
                 to_port: Optional[int] = None):
        pulumi.set(__self__, "ip_protocol", ip_protocol)
        if cidr_ip is not None:
            pulumi.set(__self__, "cidr_ip", cidr_ip)
        if cidr_ipv6 is not None:
            pulumi.set(__self__, "cidr_ipv6", cidr_ipv6)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if from_port is not None:
            pulumi.set(__self__, "from_port", from_port)
        if source_prefix_list_id is not None:
            pulumi.set(__self__, "source_prefix_list_id", source_prefix_list_id)
        if source_security_group_id is not None:
            pulumi.set(__self__, "source_security_group_id", source_security_group_id)
        if source_security_group_name is not None:
            pulumi.set(__self__, "source_security_group_name", source_security_group_name)
        if source_security_group_owner_id is not None:
            pulumi.set(__self__, "source_security_group_owner_id", source_security_group_owner_id)
        if to_port is not None:
            pulumi.set(__self__, "to_port", to_port)

    @property
    @pulumi.getter(name="ipProtocol")
    def ip_protocol(self) -> str:
        return pulumi.get(self, "ip_protocol")

    @property
    @pulumi.getter(name="cidrIp")
    def cidr_ip(self) -> Optional[str]:
        return pulumi.get(self, "cidr_ip")

    @property
    @pulumi.getter(name="cidrIpv6")
    def cidr_ipv6(self) -> Optional[str]:
        return pulumi.get(self, "cidr_ipv6")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="fromPort")
    def from_port(self) -> Optional[int]:
        return pulumi.get(self, "from_port")

    @property
    @pulumi.getter(name="sourcePrefixListId")
    def source_prefix_list_id(self) -> Optional[str]:
        return pulumi.get(self, "source_prefix_list_id")

    @property
    @pulumi.getter(name="sourceSecurityGroupId")
    def source_security_group_id(self) -> Optional[str]:
        return pulumi.get(self, "source_security_group_id")

    @property
    @pulumi.getter(name="sourceSecurityGroupName")
    def source_security_group_name(self) -> Optional[str]:
        return pulumi.get(self, "source_security_group_name")

    @property
    @pulumi.getter(name="sourceSecurityGroupOwnerId")
    def source_security_group_owner_id(self) -> Optional[str]:
        return pulumi.get(self, "source_security_group_owner_id")

    @property
    @pulumi.getter(name="toPort")
    def to_port(self) -> Optional[int]:
        return pulumi.get(self, "to_port")


@pulumi.output_type
class SecurityGroupTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class SpotFleetBlockDeviceMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deviceName":
            suggest = "device_name"
        elif key == "noDevice":
            suggest = "no_device"
        elif key == "virtualName":
            suggest = "virtual_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetBlockDeviceMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetBlockDeviceMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetBlockDeviceMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 device_name: str,
                 ebs: Optional['outputs.SpotFleetEbsBlockDevice'] = None,
                 no_device: Optional[str] = None,
                 virtual_name: Optional[str] = None):
        pulumi.set(__self__, "device_name", device_name)
        if ebs is not None:
            pulumi.set(__self__, "ebs", ebs)
        if no_device is not None:
            pulumi.set(__self__, "no_device", no_device)
        if virtual_name is not None:
            pulumi.set(__self__, "virtual_name", virtual_name)

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> str:
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter
    def ebs(self) -> Optional['outputs.SpotFleetEbsBlockDevice']:
        return pulumi.get(self, "ebs")

    @property
    @pulumi.getter(name="noDevice")
    def no_device(self) -> Optional[str]:
        return pulumi.get(self, "no_device")

    @property
    @pulumi.getter(name="virtualName")
    def virtual_name(self) -> Optional[str]:
        return pulumi.get(self, "virtual_name")


@pulumi.output_type
class SpotFleetClassicLoadBalancer(dict):
    def __init__(__self__, *,
                 name: str):
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")


@pulumi.output_type
class SpotFleetClassicLoadBalancersConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "classicLoadBalancers":
            suggest = "classic_load_balancers"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetClassicLoadBalancersConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetClassicLoadBalancersConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetClassicLoadBalancersConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 classic_load_balancers: Sequence['outputs.SpotFleetClassicLoadBalancer']):
        pulumi.set(__self__, "classic_load_balancers", classic_load_balancers)

    @property
    @pulumi.getter(name="classicLoadBalancers")
    def classic_load_balancers(self) -> Sequence['outputs.SpotFleetClassicLoadBalancer']:
        return pulumi.get(self, "classic_load_balancers")


@pulumi.output_type
class SpotFleetEbsBlockDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteOnTermination":
            suggest = "delete_on_termination"
        elif key == "snapshotId":
            suggest = "snapshot_id"
        elif key == "volumeSize":
            suggest = "volume_size"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetEbsBlockDevice. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetEbsBlockDevice.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetEbsBlockDevice.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_on_termination: Optional[bool] = None,
                 encrypted: Optional[bool] = None,
                 iops: Optional[int] = None,
                 snapshot_id: Optional[str] = None,
                 volume_size: Optional[int] = None,
                 volume_type: Optional['SpotFleetEbsBlockDeviceVolumeType'] = None):
        if delete_on_termination is not None:
            pulumi.set(__self__, "delete_on_termination", delete_on_termination)
        if encrypted is not None:
            pulumi.set(__self__, "encrypted", encrypted)
        if iops is not None:
            pulumi.set(__self__, "iops", iops)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="deleteOnTermination")
    def delete_on_termination(self) -> Optional[bool]:
        return pulumi.get(self, "delete_on_termination")

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[bool]:
        return pulumi.get(self, "encrypted")

    @property
    @pulumi.getter
    def iops(self) -> Optional[int]:
        return pulumi.get(self, "iops")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        return pulumi.get(self, "snapshot_id")

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[int]:
        return pulumi.get(self, "volume_size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional['SpotFleetEbsBlockDeviceVolumeType']:
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class SpotFleetFleetLaunchTemplateSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "launchTemplateId":
            suggest = "launch_template_id"
        elif key == "launchTemplateName":
            suggest = "launch_template_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetFleetLaunchTemplateSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetFleetLaunchTemplateSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetFleetLaunchTemplateSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 version: str,
                 launch_template_id: Optional[str] = None,
                 launch_template_name: Optional[str] = None):
        pulumi.set(__self__, "version", version)
        if launch_template_id is not None:
            pulumi.set(__self__, "launch_template_id", launch_template_id)
        if launch_template_name is not None:
            pulumi.set(__self__, "launch_template_name", launch_template_name)

    @property
    @pulumi.getter
    def version(self) -> str:
        return pulumi.get(self, "version")

    @property
    @pulumi.getter(name="launchTemplateId")
    def launch_template_id(self) -> Optional[str]:
        return pulumi.get(self, "launch_template_id")

    @property
    @pulumi.getter(name="launchTemplateName")
    def launch_template_name(self) -> Optional[str]:
        return pulumi.get(self, "launch_template_name")


@pulumi.output_type
class SpotFleetGroupIdentifier(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupId":
            suggest = "group_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetGroupIdentifier. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetGroupIdentifier.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetGroupIdentifier.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 group_id: str):
        pulumi.set(__self__, "group_id", group_id)

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> str:
        return pulumi.get(self, "group_id")


@pulumi.output_type
class SpotFleetIamInstanceProfileSpecification(dict):
    def __init__(__self__, *,
                 arn: Optional[str] = None):
        if arn is not None:
            pulumi.set(__self__, "arn", arn)

    @property
    @pulumi.getter
    def arn(self) -> Optional[str]:
        return pulumi.get(self, "arn")


@pulumi.output_type
class SpotFleetInstanceIpv6Address(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipv6Address":
            suggest = "ipv6_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetInstanceIpv6Address. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetInstanceIpv6Address.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetInstanceIpv6Address.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ipv6_address: str):
        pulumi.set(__self__, "ipv6_address", ipv6_address)

    @property
    @pulumi.getter(name="ipv6Address")
    def ipv6_address(self) -> str:
        return pulumi.get(self, "ipv6_address")


@pulumi.output_type
class SpotFleetInstanceNetworkInterfaceSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "associatePublicIpAddress":
            suggest = "associate_public_ip_address"
        elif key == "deleteOnTermination":
            suggest = "delete_on_termination"
        elif key == "deviceIndex":
            suggest = "device_index"
        elif key == "ipv6AddressCount":
            suggest = "ipv6_address_count"
        elif key == "ipv6Addresses":
            suggest = "ipv6_addresses"
        elif key == "networkInterfaceId":
            suggest = "network_interface_id"
        elif key == "privateIpAddresses":
            suggest = "private_ip_addresses"
        elif key == "secondaryPrivateIpAddressCount":
            suggest = "secondary_private_ip_address_count"
        elif key == "subnetId":
            suggest = "subnet_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetInstanceNetworkInterfaceSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetInstanceNetworkInterfaceSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetInstanceNetworkInterfaceSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 associate_public_ip_address: Optional[bool] = None,
                 delete_on_termination: Optional[bool] = None,
                 description: Optional[str] = None,
                 device_index: Optional[int] = None,
                 groups: Optional[Sequence[str]] = None,
                 ipv6_address_count: Optional[int] = None,
                 ipv6_addresses: Optional[Sequence['outputs.SpotFleetInstanceIpv6Address']] = None,
                 network_interface_id: Optional[str] = None,
                 private_ip_addresses: Optional[Sequence['outputs.SpotFleetPrivateIpAddressSpecification']] = None,
                 secondary_private_ip_address_count: Optional[int] = None,
                 subnet_id: Optional[str] = None):
        if associate_public_ip_address is not None:
            pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
        if delete_on_termination is not None:
            pulumi.set(__self__, "delete_on_termination", delete_on_termination)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if device_index is not None:
            pulumi.set(__self__, "device_index", device_index)
        if groups is not None:
            pulumi.set(__self__, "groups", groups)
        if ipv6_address_count is not None:
            pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        if ipv6_addresses is not None:
            pulumi.set(__self__, "ipv6_addresses", ipv6_addresses)
        if network_interface_id is not None:
            pulumi.set(__self__, "network_interface_id", network_interface_id)
        if private_ip_addresses is not None:
            pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        if secondary_private_ip_address_count is not None:
            pulumi.set(__self__, "secondary_private_ip_address_count", secondary_private_ip_address_count)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="associatePublicIpAddress")
    def associate_public_ip_address(self) -> Optional[bool]:
        return pulumi.get(self, "associate_public_ip_address")

    @property
    @pulumi.getter(name="deleteOnTermination")
    def delete_on_termination(self) -> Optional[bool]:
        return pulumi.get(self, "delete_on_termination")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="deviceIndex")
    def device_index(self) -> Optional[int]:
        return pulumi.get(self, "device_index")

    @property
    @pulumi.getter
    def groups(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "groups")

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> Optional[int]:
        return pulumi.get(self, "ipv6_address_count")

    @property
    @pulumi.getter(name="ipv6Addresses")
    def ipv6_addresses(self) -> Optional[Sequence['outputs.SpotFleetInstanceIpv6Address']]:
        return pulumi.get(self, "ipv6_addresses")

    @property
    @pulumi.getter(name="networkInterfaceId")
    def network_interface_id(self) -> Optional[str]:
        return pulumi.get(self, "network_interface_id")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Optional[Sequence['outputs.SpotFleetPrivateIpAddressSpecification']]:
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="secondaryPrivateIpAddressCount")
    def secondary_private_ip_address_count(self) -> Optional[int]:
        return pulumi.get(self, "secondary_private_ip_address_count")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class SpotFleetLaunchTemplateConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "launchTemplateSpecification":
            suggest = "launch_template_specification"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetLaunchTemplateConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetLaunchTemplateConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetLaunchTemplateConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 launch_template_specification: Optional['outputs.SpotFleetFleetLaunchTemplateSpecification'] = None,
                 overrides: Optional[Sequence['outputs.SpotFleetLaunchTemplateOverrides']] = None):
        if launch_template_specification is not None:
            pulumi.set(__self__, "launch_template_specification", launch_template_specification)
        if overrides is not None:
            pulumi.set(__self__, "overrides", overrides)

    @property
    @pulumi.getter(name="launchTemplateSpecification")
    def launch_template_specification(self) -> Optional['outputs.SpotFleetFleetLaunchTemplateSpecification']:
        return pulumi.get(self, "launch_template_specification")

    @property
    @pulumi.getter
    def overrides(self) -> Optional[Sequence['outputs.SpotFleetLaunchTemplateOverrides']]:
        return pulumi.get(self, "overrides")


@pulumi.output_type
class SpotFleetLaunchTemplateOverrides(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "spotPrice":
            suggest = "spot_price"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "weightedCapacity":
            suggest = "weighted_capacity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetLaunchTemplateOverrides. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetLaunchTemplateOverrides.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetLaunchTemplateOverrides.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 availability_zone: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 spot_price: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 weighted_capacity: Optional[float] = None):
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if spot_price is not None:
            pulumi.set(__self__, "spot_price", spot_price)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[str]:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[str]:
        return pulumi.get(self, "spot_price")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="weightedCapacity")
    def weighted_capacity(self) -> Optional[float]:
        return pulumi.get(self, "weighted_capacity")


@pulumi.output_type
class SpotFleetLoadBalancersConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "classicLoadBalancersConfig":
            suggest = "classic_load_balancers_config"
        elif key == "targetGroupsConfig":
            suggest = "target_groups_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetLoadBalancersConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetLoadBalancersConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetLoadBalancersConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 classic_load_balancers_config: Optional['outputs.SpotFleetClassicLoadBalancersConfig'] = None,
                 target_groups_config: Optional['outputs.SpotFleetTargetGroupsConfig'] = None):
        if classic_load_balancers_config is not None:
            pulumi.set(__self__, "classic_load_balancers_config", classic_load_balancers_config)
        if target_groups_config is not None:
            pulumi.set(__self__, "target_groups_config", target_groups_config)

    @property
    @pulumi.getter(name="classicLoadBalancersConfig")
    def classic_load_balancers_config(self) -> Optional['outputs.SpotFleetClassicLoadBalancersConfig']:
        return pulumi.get(self, "classic_load_balancers_config")

    @property
    @pulumi.getter(name="targetGroupsConfig")
    def target_groups_config(self) -> Optional['outputs.SpotFleetTargetGroupsConfig']:
        return pulumi.get(self, "target_groups_config")


@pulumi.output_type
class SpotFleetPrivateIpAddressSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateIpAddress":
            suggest = "private_ip_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetPrivateIpAddressSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetPrivateIpAddressSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetPrivateIpAddressSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_ip_address: str,
                 primary: Optional[bool] = None):
        pulumi.set(__self__, "private_ip_address", private_ip_address)
        if primary is not None:
            pulumi.set(__self__, "primary", primary)

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> str:
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter
    def primary(self) -> Optional[bool]:
        return pulumi.get(self, "primary")


@pulumi.output_type
class SpotFleetSpotCapacityRebalance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "replacementStrategy":
            suggest = "replacement_strategy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetSpotCapacityRebalance. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetSpotCapacityRebalance.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetSpotCapacityRebalance.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 replacement_strategy: Optional['SpotFleetSpotCapacityRebalanceReplacementStrategy'] = None):
        if replacement_strategy is not None:
            pulumi.set(__self__, "replacement_strategy", replacement_strategy)

    @property
    @pulumi.getter(name="replacementStrategy")
    def replacement_strategy(self) -> Optional['SpotFleetSpotCapacityRebalanceReplacementStrategy']:
        return pulumi.get(self, "replacement_strategy")


@pulumi.output_type
class SpotFleetSpotFleetLaunchSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageId":
            suggest = "image_id"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "blockDeviceMappings":
            suggest = "block_device_mappings"
        elif key == "ebsOptimized":
            suggest = "ebs_optimized"
        elif key == "iamInstanceProfile":
            suggest = "iam_instance_profile"
        elif key == "kernelId":
            suggest = "kernel_id"
        elif key == "keyName":
            suggest = "key_name"
        elif key == "networkInterfaces":
            suggest = "network_interfaces"
        elif key == "ramdiskId":
            suggest = "ramdisk_id"
        elif key == "securityGroups":
            suggest = "security_groups"
        elif key == "spotPrice":
            suggest = "spot_price"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "tagSpecifications":
            suggest = "tag_specifications"
        elif key == "userData":
            suggest = "user_data"
        elif key == "weightedCapacity":
            suggest = "weighted_capacity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetSpotFleetLaunchSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetSpotFleetLaunchSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetSpotFleetLaunchSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 image_id: str,
                 instance_type: str,
                 block_device_mappings: Optional[Sequence['outputs.SpotFleetBlockDeviceMapping']] = None,
                 ebs_optimized: Optional[bool] = None,
                 iam_instance_profile: Optional['outputs.SpotFleetIamInstanceProfileSpecification'] = None,
                 kernel_id: Optional[str] = None,
                 key_name: Optional[str] = None,
                 monitoring: Optional['outputs.SpotFleetSpotFleetMonitoring'] = None,
                 network_interfaces: Optional[Sequence['outputs.SpotFleetInstanceNetworkInterfaceSpecification']] = None,
                 placement: Optional['outputs.SpotFleetSpotPlacement'] = None,
                 ramdisk_id: Optional[str] = None,
                 security_groups: Optional[Sequence['outputs.SpotFleetGroupIdentifier']] = None,
                 spot_price: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 tag_specifications: Optional[Sequence['outputs.SpotFleetSpotFleetTagSpecification']] = None,
                 user_data: Optional[str] = None,
                 weighted_capacity: Optional[float] = None):
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "instance_type", instance_type)
        if block_device_mappings is not None:
            pulumi.set(__self__, "block_device_mappings", block_device_mappings)
        if ebs_optimized is not None:
            pulumi.set(__self__, "ebs_optimized", ebs_optimized)
        if iam_instance_profile is not None:
            pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
        if kernel_id is not None:
            pulumi.set(__self__, "kernel_id", kernel_id)
        if key_name is not None:
            pulumi.set(__self__, "key_name", key_name)
        if monitoring is not None:
            pulumi.set(__self__, "monitoring", monitoring)
        if network_interfaces is not None:
            pulumi.set(__self__, "network_interfaces", network_interfaces)
        if placement is not None:
            pulumi.set(__self__, "placement", placement)
        if ramdisk_id is not None:
            pulumi.set(__self__, "ramdisk_id", ramdisk_id)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if spot_price is not None:
            pulumi.set(__self__, "spot_price", spot_price)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if tag_specifications is not None:
            pulumi.set(__self__, "tag_specifications", tag_specifications)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> str:
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> str:
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="blockDeviceMappings")
    def block_device_mappings(self) -> Optional[Sequence['outputs.SpotFleetBlockDeviceMapping']]:
        return pulumi.get(self, "block_device_mappings")

    @property
    @pulumi.getter(name="ebsOptimized")
    def ebs_optimized(self) -> Optional[bool]:
        return pulumi.get(self, "ebs_optimized")

    @property
    @pulumi.getter(name="iamInstanceProfile")
    def iam_instance_profile(self) -> Optional['outputs.SpotFleetIamInstanceProfileSpecification']:
        return pulumi.get(self, "iam_instance_profile")

    @property
    @pulumi.getter(name="kernelId")
    def kernel_id(self) -> Optional[str]:
        return pulumi.get(self, "kernel_id")

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> Optional[str]:
        return pulumi.get(self, "key_name")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional['outputs.SpotFleetSpotFleetMonitoring']:
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="networkInterfaces")
    def network_interfaces(self) -> Optional[Sequence['outputs.SpotFleetInstanceNetworkInterfaceSpecification']]:
        return pulumi.get(self, "network_interfaces")

    @property
    @pulumi.getter
    def placement(self) -> Optional['outputs.SpotFleetSpotPlacement']:
        return pulumi.get(self, "placement")

    @property
    @pulumi.getter(name="ramdiskId")
    def ramdisk_id(self) -> Optional[str]:
        return pulumi.get(self, "ramdisk_id")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[Sequence['outputs.SpotFleetGroupIdentifier']]:
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[str]:
        return pulumi.get(self, "spot_price")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="tagSpecifications")
    def tag_specifications(self) -> Optional[Sequence['outputs.SpotFleetSpotFleetTagSpecification']]:
        return pulumi.get(self, "tag_specifications")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[str]:
        return pulumi.get(self, "user_data")

    @property
    @pulumi.getter(name="weightedCapacity")
    def weighted_capacity(self) -> Optional[float]:
        return pulumi.get(self, "weighted_capacity")


@pulumi.output_type
class SpotFleetSpotFleetMonitoring(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class SpotFleetSpotFleetRequestConfigData(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "iamFleetRole":
            suggest = "iam_fleet_role"
        elif key == "targetCapacity":
            suggest = "target_capacity"
        elif key == "allocationStrategy":
            suggest = "allocation_strategy"
        elif key == "excessCapacityTerminationPolicy":
            suggest = "excess_capacity_termination_policy"
        elif key == "instanceInterruptionBehavior":
            suggest = "instance_interruption_behavior"
        elif key == "instancePoolsToUseCount":
            suggest = "instance_pools_to_use_count"
        elif key == "launchSpecifications":
            suggest = "launch_specifications"
        elif key == "launchTemplateConfigs":
            suggest = "launch_template_configs"
        elif key == "loadBalancersConfig":
            suggest = "load_balancers_config"
        elif key == "onDemandAllocationStrategy":
            suggest = "on_demand_allocation_strategy"
        elif key == "onDemandMaxTotalPrice":
            suggest = "on_demand_max_total_price"
        elif key == "onDemandTargetCapacity":
            suggest = "on_demand_target_capacity"
        elif key == "replaceUnhealthyInstances":
            suggest = "replace_unhealthy_instances"
        elif key == "spotMaintenanceStrategies":
            suggest = "spot_maintenance_strategies"
        elif key == "spotMaxTotalPrice":
            suggest = "spot_max_total_price"
        elif key == "spotPrice":
            suggest = "spot_price"
        elif key == "terminateInstancesWithExpiration":
            suggest = "terminate_instances_with_expiration"
        elif key == "validFrom":
            suggest = "valid_from"
        elif key == "validUntil":
            suggest = "valid_until"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetSpotFleetRequestConfigData. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetSpotFleetRequestConfigData.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetSpotFleetRequestConfigData.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 iam_fleet_role: str,
                 target_capacity: int,
                 allocation_strategy: Optional['SpotFleetSpotFleetRequestConfigDataAllocationStrategy'] = None,
                 context: Optional[str] = None,
                 excess_capacity_termination_policy: Optional['SpotFleetSpotFleetRequestConfigDataExcessCapacityTerminationPolicy'] = None,
                 instance_interruption_behavior: Optional['SpotFleetSpotFleetRequestConfigDataInstanceInterruptionBehavior'] = None,
                 instance_pools_to_use_count: Optional[int] = None,
                 launch_specifications: Optional[Sequence['outputs.SpotFleetSpotFleetLaunchSpecification']] = None,
                 launch_template_configs: Optional[Sequence['outputs.SpotFleetLaunchTemplateConfig']] = None,
                 load_balancers_config: Optional['outputs.SpotFleetLoadBalancersConfig'] = None,
                 on_demand_allocation_strategy: Optional[str] = None,
                 on_demand_max_total_price: Optional[str] = None,
                 on_demand_target_capacity: Optional[int] = None,
                 replace_unhealthy_instances: Optional[bool] = None,
                 spot_maintenance_strategies: Optional['outputs.SpotFleetSpotMaintenanceStrategies'] = None,
                 spot_max_total_price: Optional[str] = None,
                 spot_price: Optional[str] = None,
                 terminate_instances_with_expiration: Optional[bool] = None,
                 type: Optional['SpotFleetSpotFleetRequestConfigDataType'] = None,
                 valid_from: Optional[str] = None,
                 valid_until: Optional[str] = None):
        pulumi.set(__self__, "iam_fleet_role", iam_fleet_role)
        pulumi.set(__self__, "target_capacity", target_capacity)
        if allocation_strategy is not None:
            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
        if context is not None:
            pulumi.set(__self__, "context", context)
        if excess_capacity_termination_policy is not None:
            pulumi.set(__self__, "excess_capacity_termination_policy", excess_capacity_termination_policy)
        if instance_interruption_behavior is not None:
            pulumi.set(__self__, "instance_interruption_behavior", instance_interruption_behavior)
        if instance_pools_to_use_count is not None:
            pulumi.set(__self__, "instance_pools_to_use_count", instance_pools_to_use_count)
        if launch_specifications is not None:
            pulumi.set(__self__, "launch_specifications", launch_specifications)
        if launch_template_configs is not None:
            pulumi.set(__self__, "launch_template_configs", launch_template_configs)
        if load_balancers_config is not None:
            pulumi.set(__self__, "load_balancers_config", load_balancers_config)
        if on_demand_allocation_strategy is not None:
            pulumi.set(__self__, "on_demand_allocation_strategy", on_demand_allocation_strategy)
        if on_demand_max_total_price is not None:
            pulumi.set(__self__, "on_demand_max_total_price", on_demand_max_total_price)
        if on_demand_target_capacity is not None:
            pulumi.set(__self__, "on_demand_target_capacity", on_demand_target_capacity)
        if replace_unhealthy_instances is not None:
            pulumi.set(__self__, "replace_unhealthy_instances", replace_unhealthy_instances)
        if spot_maintenance_strategies is not None:
            pulumi.set(__self__, "spot_maintenance_strategies", spot_maintenance_strategies)
        if spot_max_total_price is not None:
            pulumi.set(__self__, "spot_max_total_price", spot_max_total_price)
        if spot_price is not None:
            pulumi.set(__self__, "spot_price", spot_price)
        if terminate_instances_with_expiration is not None:
            pulumi.set(__self__, "terminate_instances_with_expiration", terminate_instances_with_expiration)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if valid_from is not None:
            pulumi.set(__self__, "valid_from", valid_from)
        if valid_until is not None:
            pulumi.set(__self__, "valid_until", valid_until)

    @property
    @pulumi.getter(name="iamFleetRole")
    def iam_fleet_role(self) -> str:
        return pulumi.get(self, "iam_fleet_role")

    @property
    @pulumi.getter(name="targetCapacity")
    def target_capacity(self) -> int:
        return pulumi.get(self, "target_capacity")

    @property
    @pulumi.getter(name="allocationStrategy")
    def allocation_strategy(self) -> Optional['SpotFleetSpotFleetRequestConfigDataAllocationStrategy']:
        return pulumi.get(self, "allocation_strategy")

    @property
    @pulumi.getter
    def context(self) -> Optional[str]:
        return pulumi.get(self, "context")

    @property
    @pulumi.getter(name="excessCapacityTerminationPolicy")
    def excess_capacity_termination_policy(self) -> Optional['SpotFleetSpotFleetRequestConfigDataExcessCapacityTerminationPolicy']:
        return pulumi.get(self, "excess_capacity_termination_policy")

    @property
    @pulumi.getter(name="instanceInterruptionBehavior")
    def instance_interruption_behavior(self) -> Optional['SpotFleetSpotFleetRequestConfigDataInstanceInterruptionBehavior']:
        return pulumi.get(self, "instance_interruption_behavior")

    @property
    @pulumi.getter(name="instancePoolsToUseCount")
    def instance_pools_to_use_count(self) -> Optional[int]:
        return pulumi.get(self, "instance_pools_to_use_count")

    @property
    @pulumi.getter(name="launchSpecifications")
    def launch_specifications(self) -> Optional[Sequence['outputs.SpotFleetSpotFleetLaunchSpecification']]:
        return pulumi.get(self, "launch_specifications")

    @property
    @pulumi.getter(name="launchTemplateConfigs")
    def launch_template_configs(self) -> Optional[Sequence['outputs.SpotFleetLaunchTemplateConfig']]:
        return pulumi.get(self, "launch_template_configs")

    @property
    @pulumi.getter(name="loadBalancersConfig")
    def load_balancers_config(self) -> Optional['outputs.SpotFleetLoadBalancersConfig']:
        return pulumi.get(self, "load_balancers_config")

    @property
    @pulumi.getter(name="onDemandAllocationStrategy")
    def on_demand_allocation_strategy(self) -> Optional[str]:
        return pulumi.get(self, "on_demand_allocation_strategy")

    @property
    @pulumi.getter(name="onDemandMaxTotalPrice")
    def on_demand_max_total_price(self) -> Optional[str]:
        return pulumi.get(self, "on_demand_max_total_price")

    @property
    @pulumi.getter(name="onDemandTargetCapacity")
    def on_demand_target_capacity(self) -> Optional[int]:
        return pulumi.get(self, "on_demand_target_capacity")

    @property
    @pulumi.getter(name="replaceUnhealthyInstances")
    def replace_unhealthy_instances(self) -> Optional[bool]:
        return pulumi.get(self, "replace_unhealthy_instances")

    @property
    @pulumi.getter(name="spotMaintenanceStrategies")
    def spot_maintenance_strategies(self) -> Optional['outputs.SpotFleetSpotMaintenanceStrategies']:
        return pulumi.get(self, "spot_maintenance_strategies")

    @property
    @pulumi.getter(name="spotMaxTotalPrice")
    def spot_max_total_price(self) -> Optional[str]:
        return pulumi.get(self, "spot_max_total_price")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[str]:
        return pulumi.get(self, "spot_price")

    @property
    @pulumi.getter(name="terminateInstancesWithExpiration")
    def terminate_instances_with_expiration(self) -> Optional[bool]:
        return pulumi.get(self, "terminate_instances_with_expiration")

    @property
    @pulumi.getter
    def type(self) -> Optional['SpotFleetSpotFleetRequestConfigDataType']:
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="validFrom")
    def valid_from(self) -> Optional[str]:
        return pulumi.get(self, "valid_from")

    @property
    @pulumi.getter(name="validUntil")
    def valid_until(self) -> Optional[str]:
        return pulumi.get(self, "valid_until")


@pulumi.output_type
class SpotFleetSpotFleetTagSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceType":
            suggest = "resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetSpotFleetTagSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetSpotFleetTagSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetSpotFleetTagSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_type: Optional['SpotFleetSpotFleetTagSpecificationResourceType'] = None,
                 tags: Optional[Sequence['outputs.SpotFleetTag']] = None):
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional['SpotFleetSpotFleetTagSpecificationResourceType']:
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence['outputs.SpotFleetTag']]:
        return pulumi.get(self, "tags")


@pulumi.output_type
class SpotFleetSpotMaintenanceStrategies(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "capacityRebalance":
            suggest = "capacity_rebalance"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetSpotMaintenanceStrategies. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetSpotMaintenanceStrategies.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetSpotMaintenanceStrategies.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 capacity_rebalance: Optional['outputs.SpotFleetSpotCapacityRebalance'] = None):
        if capacity_rebalance is not None:
            pulumi.set(__self__, "capacity_rebalance", capacity_rebalance)

    @property
    @pulumi.getter(name="capacityRebalance")
    def capacity_rebalance(self) -> Optional['outputs.SpotFleetSpotCapacityRebalance']:
        return pulumi.get(self, "capacity_rebalance")


@pulumi.output_type
class SpotFleetSpotPlacement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "groupName":
            suggest = "group_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetSpotPlacement. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetSpotPlacement.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetSpotPlacement.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 availability_zone: Optional[str] = None,
                 group_name: Optional[str] = None,
                 tenancy: Optional['SpotFleetSpotPlacementTenancy'] = None):
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if group_name is not None:
            pulumi.set(__self__, "group_name", group_name)
        if tenancy is not None:
            pulumi.set(__self__, "tenancy", tenancy)

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[str]:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="groupName")
    def group_name(self) -> Optional[str]:
        return pulumi.get(self, "group_name")

    @property
    @pulumi.getter
    def tenancy(self) -> Optional['SpotFleetSpotPlacementTenancy']:
        return pulumi.get(self, "tenancy")


@pulumi.output_type
class SpotFleetTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class SpotFleetTargetGroup(dict):
    def __init__(__self__, *,
                 arn: str):
        pulumi.set(__self__, "arn", arn)

    @property
    @pulumi.getter
    def arn(self) -> str:
        return pulumi.get(self, "arn")


@pulumi.output_type
class SpotFleetTargetGroupsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetGroups":
            suggest = "target_groups"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpotFleetTargetGroupsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpotFleetTargetGroupsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpotFleetTargetGroupsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 target_groups: Sequence['outputs.SpotFleetTargetGroup']):
        pulumi.set(__self__, "target_groups", target_groups)

    @property
    @pulumi.getter(name="targetGroups")
    def target_groups(self) -> Sequence['outputs.SpotFleetTargetGroup']:
        return pulumi.get(self, "target_groups")


@pulumi.output_type
class SubnetTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class TrafficMirrorFilterRuleTrafficMirrorPortRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fromPort":
            suggest = "from_port"
        elif key == "toPort":
            suggest = "to_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TrafficMirrorFilterRuleTrafficMirrorPortRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TrafficMirrorFilterRuleTrafficMirrorPortRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TrafficMirrorFilterRuleTrafficMirrorPortRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 from_port: int,
                 to_port: int):
        pulumi.set(__self__, "from_port", from_port)
        pulumi.set(__self__, "to_port", to_port)

    @property
    @pulumi.getter(name="fromPort")
    def from_port(self) -> int:
        return pulumi.get(self, "from_port")

    @property
    @pulumi.getter(name="toPort")
    def to_port(self) -> int:
        return pulumi.get(self, "to_port")


@pulumi.output_type
class TrafficMirrorFilterTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class TrafficMirrorSessionTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class TrafficMirrorTargetTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class TransitGatewayAttachmentTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class TransitGatewayConnectTag(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str key: The key of the tag. Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode characters. May not begin with aws:.
        :param str value: The value of the tag. Constraints: Tag values are case-sensitive and accept a maximum of 255 Unicode characters.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The key of the tag. Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode characters. May not begin with aws:.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        The value of the tag. Constraints: Tag values are case-sensitive and accept a maximum of 255 Unicode characters.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TransitGatewayConnectTransitGatewayConnectOptions(dict):
    def __init__(__self__, *,
                 protocol: Optional[str] = None):
        """
        :param str protocol: The tunnel protocol.
        """
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The tunnel protocol.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class TransitGatewayMulticastDomainTag(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str key: The key of the tag. Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode characters. May not begin with aws:.
        :param str value: The value of the tag. Constraints: Tag values are case-sensitive and accept a maximum of 255 Unicode characters.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The key of the tag. Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode characters. May not begin with aws:.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        The value of the tag. Constraints: Tag values are case-sensitive and accept a maximum of 255 Unicode characters.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TransitGatewayPeeringAttachmentPeeringAttachmentStatus(dict):
    def __init__(__self__, *,
                 code: Optional[str] = None,
                 message: Optional[str] = None):
        """
        :param str code: The status code.
        :param str message: The status message, if applicable.
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if message is not None:
            pulumi.set(__self__, "message", message)

    @property
    @pulumi.getter
    def code(self) -> Optional[str]:
        """
        The status code.
        """
        return pulumi.get(self, "code")

    @property
    @pulumi.getter
    def message(self) -> Optional[str]:
        """
        The status message, if applicable.
        """
        return pulumi.get(self, "message")


@pulumi.output_type
class TransitGatewayPeeringAttachmentTag(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str key: The key of the tag. Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode characters. May not begin with aws:.
        :param str value: The value of the tag. Constraints: Tag values are case-sensitive and accept a maximum of 255 Unicode characters.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The key of the tag. Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode characters. May not begin with aws:.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        The value of the tag. Constraints: Tag values are case-sensitive and accept a maximum of 255 Unicode characters.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TransitGatewayRouteTableTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class TransitGatewayTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class TransitGatewayVpcAttachmentTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class VPCPeeringConnectionTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class VPCTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class VPNConnectionTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class VPNConnectionVpnTunnelOptionsSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "preSharedKey":
            suggest = "pre_shared_key"
        elif key == "tunnelInsideCidr":
            suggest = "tunnel_inside_cidr"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in VPNConnectionVpnTunnelOptionsSpecification. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        VPNConnectionVpnTunnelOptionsSpecification.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        VPNConnectionVpnTunnelOptionsSpecification.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pre_shared_key: Optional[str] = None,
                 tunnel_inside_cidr: Optional[str] = None):
        if pre_shared_key is not None:
            pulumi.set(__self__, "pre_shared_key", pre_shared_key)
        if tunnel_inside_cidr is not None:
            pulumi.set(__self__, "tunnel_inside_cidr", tunnel_inside_cidr)

    @property
    @pulumi.getter(name="preSharedKey")
    def pre_shared_key(self) -> Optional[str]:
        return pulumi.get(self, "pre_shared_key")

    @property
    @pulumi.getter(name="tunnelInsideCidr")
    def tunnel_inside_cidr(self) -> Optional[str]:
        return pulumi.get(self, "tunnel_inside_cidr")


@pulumi.output_type
class VPNGatewayTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class VolumeTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


