@horietakehiro/aws-cdk-utul 0.41.56 → 0.41.57

package/lib/types/cfn-resource-types/aws-ec2-spotfleet.d.ts

@@ -2,95 +2,142 @@
  * Resource Type definition for AWS::EC2::SpotFleet
  */
 export interface _AWS_EC2_SPOTFLEET {
-    SpotFleetRequestConfigData: SpotFleetRequestConfigData;
     Id?: string;
+    SpotFleetRequestConfigData: SpotFleetRequestConfigData;
     /**
      * The tags to specify in SpotFleetRequestConfigData
      */
     Tags?: Tag[];
 }
 export interface SpotFleetRequestConfigData {
+    AllocationStrategy?: ("capacityOptimized" | "capacityOptimizedPrioritized" | "diversified" | "lowestPrice" | "priceCapacityOptimized");
     Context?: string;
-    SpotMaxTotalPrice?: string;
     ExcessCapacityTerminationPolicy?: ("Default" | "NoTermination" | "default" | "noTermination");
-    TagSpecifications?: SpotFleetTagSpecification[];
+    IamFleetRole: string;
+    InstanceInterruptionBehavior?: ("hibernate" | "stop" | "terminate");
     InstancePoolsToUseCount?: number;
+    LaunchSpecifications?: SpotFleetLaunchSpecification[];
     LaunchTemplateConfigs?: LaunchTemplateConfig[];
-    TargetCapacityUnitType?: ("vcpu" | "memory-mib" | "units");
-    IamFleetRole: string;
-    SpotMaintenanceStrategies?: SpotMaintenanceStrategies;
-    TerminateInstancesWithExpiration?: boolean;
-    ValidUntil?: string;
-    OnDemandMaxTotalPrice?: string;
+    LoadBalancersConfig?: LoadBalancersConfig;
     OnDemandAllocationStrategy?: string;
-    SpotPrice?: string;
-    AllocationStrategy?: ("capacityOptimized" | "capacityOptimizedPrioritized" | "diversified" | "lowestPrice" | "priceCapacityOptimized");
+    OnDemandMaxTotalPrice?: string;
     OnDemandTargetCapacity?: number;
-    Type?: ("maintain" | "request");
-    LaunchSpecifications?: SpotFleetLaunchSpecification[];
-    InstanceInterruptionBehavior?: ("hibernate" | "stop" | "terminate");
-    LoadBalancersConfig?: LoadBalancersConfig;
-    ValidFrom?: string;
     ReplaceUnhealthyInstances?: boolean;
+    SpotMaintenanceStrategies?: SpotMaintenanceStrategies;
+    SpotMaxTotalPrice?: string;
+    SpotPrice?: string;
     TargetCapacity: number;
+    TerminateInstancesWithExpiration?: boolean;
+    Type?: ("maintain" | "request");
+    ValidFrom?: string;
+    ValidUntil?: string;
+    TagSpecifications?: SpotFleetTagSpecification[];
+    TargetCapacityUnitType?: ("vcpu" | "memory-mib" | "units");
+}
+export interface SpotFleetLaunchSpecification {
+    BlockDeviceMappings?: BlockDeviceMapping[];
+    EbsOptimized?: boolean;
+    IamInstanceProfile?: IamInstanceProfileSpecification;
+    ImageId: string;
+    InstanceType?: string;
+    KernelId?: string;
+    KeyName?: string;
+    Monitoring?: SpotFleetMonitoring;
+    NetworkInterfaces?: InstanceNetworkInterfaceSpecification[];
+    Placement?: SpotPlacement;
+    RamdiskId?: string;
+    SecurityGroups?: GroupIdentifier[];
+    SpotPrice?: string;
+    SubnetId?: string;
+    TagSpecifications?: SpotFleetTagSpecification[];
+    UserData?: string;
+    WeightedCapacity?: number;
+    InstanceRequirements?: InstanceRequirementsRequest;
+}
+export interface BlockDeviceMapping {
+    DeviceName: string;
+    Ebs?: EbsBlockDevice;
+    NoDevice?: string;
+    VirtualName?: string;
+}
+export interface EbsBlockDevice {
+    DeleteOnTermination?: boolean;
+    Encrypted?: boolean;
+    Iops?: number;
+    SnapshotId?: string;
+    VolumeSize?: number;
+    VolumeType?: ("gp2" | "gp3" | "io1" | "io2" | "sc1" | "st1" | "standard");
+}
+export interface IamInstanceProfileSpecification {
+    Arn?: string;
+}
+export interface SpotFleetMonitoring {
+    Enabled?: boolean;
+}
+export interface InstanceNetworkInterfaceSpecification {
+    AssociatePublicIpAddress?: boolean;
+    DeleteOnTermination?: boolean;
+    Description?: string;
+    DeviceIndex?: number;
+    Groups?: string[];
+    Ipv6AddressCount?: number;
+    Ipv6Addresses?: InstanceIpv6Address[];
+    NetworkInterfaceId?: string;
+    PrivateIpAddresses?: PrivateIpAddressSpecification[];
+    SecondaryPrivateIpAddressCount?: number;
+    SubnetId?: string;
+}
+export interface InstanceIpv6Address {
+    Ipv6Address: string;
+}
+export interface PrivateIpAddressSpecification {
+    Primary?: boolean;
+    PrivateIpAddress: string;
+}
+export interface SpotPlacement {
+    AvailabilityZone?: string;
+    AvailabilityZoneId?: string;
+    GroupName?: string;
+    Tenancy?: ("dedicated" | "default" | "host");
+}
+export interface GroupIdentifier {
+    GroupId: string;
 }
 export interface SpotFleetTagSpecification {
     ResourceType?: ("client-vpn-endpoint" | "customer-gateway" | "dedicated-host" | "dhcp-options" | "egress-only-internet-gateway" | "elastic-gpu" | "elastic-ip" | "export-image-task" | "export-instance-task" | "fleet" | "fpga-image" | "host-reservation" | "image" | "import-image-task" | "import-snapshot-task" | "instance" | "internet-gateway" | "key-pair" | "launch-template" | "local-gateway-route-table-vpc-association" | "natgateway" | "network-acl" | "network-insights-analysis" | "network-insights-path" | "network-interface" | "placement-group" | "reserved-instances" | "route-table" | "security-group" | "snapshot" | "spot-fleet-request" | "spot-instances-request" | "subnet" | "traffic-mirror-filter" | "traffic-mirror-session" | "traffic-mirror-target" | "transit-gateway" | "transit-gateway-attachment" | "transit-gateway-connect-peer" | "transit-gateway-multicast-domain" | "transit-gateway-route-table" | "volume" | "vpc" | "vpc-flow-log" | "vpc-peering-connection" | "vpn-connection" | "vpn-gateway");
     Tags?: Tag[];
 }
 export interface Tag {
-    Value: string;
     Key: string;
-}
-export interface LaunchTemplateConfig {
-    LaunchTemplateSpecification?: FleetLaunchTemplateSpecification;
-    Overrides?: LaunchTemplateOverrides[];
-}
-export interface FleetLaunchTemplateSpecification {
-    LaunchTemplateName?: string;
-    Version: string;
-    LaunchTemplateId?: string;
-}
-export interface LaunchTemplateOverrides {
-    SpotPrice?: string;
-    WeightedCapacity?: number;
-    Priority?: number;
-    AvailabilityZone?: string;
-    SubnetId?: string;
-    InstanceRequirements?: InstanceRequirementsRequest;
-    InstanceType?: string;
+    Value: string;
 }
 export interface InstanceRequirementsRequest {
-    InstanceGenerations?: ("current" | "previous")[];
-    RequireEncryptionInTransit?: boolean;
-    MemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest;
-    AcceleratorTypes?: ("gpu" | "fpga" | "inference" | "media")[];
     VCpuCount?: VCpuCountRangeRequest;
-    AcceleratorManufacturers?: ("amazon-web-services" | "amd" | "habana" | "nvidia" | "xilinx")[];
-    LocalStorage?: ("included" | "required" | "excluded");
+    MemoryMiB?: MemoryMiBRequest;
     CpuManufacturers?: ("intel" | "amd" | "amazon-web-services" | "apple")[];
+    MemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest;
+    AllowedInstanceTypes?: string[];
+    ExcludedInstanceTypes?: string[];
+    InstanceGenerations?: ("current" | "previous")[];
+    SpotMaxPricePercentageOverLowestPrice?: number;
+    OnDemandMaxPricePercentageOverLowestPrice?: number;
+    MaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number;
     BareMetal?: ("included" | "required" | "excluded");
+    BurstablePerformance?: ("included" | "required" | "excluded");
     RequireHibernateSupport?: boolean;
-    MaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number;
-    OnDemandMaxPricePercentageOverLowestPrice?: number;
-    MemoryMiB?: MemoryMiBRequest;
-    LocalStorageTypes?: ("hdd" | "ssd")[];
-    NetworkInterfaceCount?: NetworkInterfaceCountRequest;
-    ExcludedInstanceTypes?: string[];
-    AllowedInstanceTypes?: string[];
     NetworkBandwidthGbps?: NetworkBandwidthGbpsRequest;
-    AcceleratorCount?: AcceleratorCountRequest;
-    BaselinePerformanceFactors?: BaselinePerformanceFactorsRequest;
-    SpotMaxPricePercentageOverLowestPrice?: number;
+    NetworkInterfaceCount?: NetworkInterfaceCountRequest;
+    LocalStorage?: ("included" | "required" | "excluded");
+    LocalStorageTypes?: ("hdd" | "ssd")[];
+    TotalLocalStorageGB?: TotalLocalStorageGBRequest;
     BaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest;
+    AcceleratorTypes?: ("gpu" | "fpga" | "inference" | "media")[];
+    AcceleratorCount?: AcceleratorCountRequest;
+    AcceleratorManufacturers?: ("amazon-web-services" | "amd" | "habana" | "nvidia" | "xilinx")[];
     AcceleratorNames?: ("a10g" | "a100" | "h100" | "inferentia" | "k520" | "k80" | "m60" | "radeon-pro-v520" | "t4" | "t4g" | "vu9p" | "v100" | "l40s" | "l4" | "gaudi-hl-205" | "inferentia2" | "trainium" | "trainium2" | "u30")[];
     AcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest;
-    BurstablePerformance?: ("included" | "required" | "excluded");
-    TotalLocalStorageGB?: TotalLocalStorageGBRequest;
-}
-export interface MemoryGiBPerVCpuRequest {
-    Min?: number;
-    Max?: number;
+    BaselinePerformanceFactors?: BaselinePerformanceFactorsRequest;
+    RequireEncryptionInTransit?: boolean;
 }
 export interface VCpuCountRangeRequest {
     Min?: number;
@@ -100,7 +147,7 @@ export interface MemoryMiBRequest {
     Min?: number;
     Max?: number;
 }
-export interface NetworkInterfaceCountRequest {
+export interface MemoryGiBPerVCpuRequest {
     Min?: number;
     Max?: number;
 }
@@ -108,105 +155,53 @@ export interface NetworkBandwidthGbpsRequest {
     Min?: number;
     Max?: number;
 }
-export interface AcceleratorCountRequest {
+export interface NetworkInterfaceCountRequest {
     Min?: number;
     Max?: number;
 }
-export interface BaselinePerformanceFactorsRequest {
-    Cpu?: CpuPerformanceFactorRequest;
-}
-export interface CpuPerformanceFactorRequest {
-    References?: PerformanceFactorReferenceRequest[];
-}
-export interface PerformanceFactorReferenceRequest {
-    InstanceFamily?: string;
+export interface TotalLocalStorageGBRequest {
+    Min?: number;
+    Max?: number;
 }
 export interface BaselineEbsBandwidthMbpsRequest {
     Min?: number;
     Max?: number;
 }
-export interface AcceleratorTotalMemoryMiBRequest {
+export interface AcceleratorCountRequest {
     Min?: number;
     Max?: number;
 }
-export interface TotalLocalStorageGBRequest {
+export interface AcceleratorTotalMemoryMiBRequest {
     Min?: number;
     Max?: number;
 }
-export interface SpotMaintenanceStrategies {
-    CapacityRebalance?: SpotCapacityRebalance;
-}
-export interface SpotCapacityRebalance {
-    TerminationDelay?: number;
-    ReplacementStrategy?: ("launch" | "launch-before-terminate");
-}
-export interface SpotFleetLaunchSpecification {
-    SecurityGroups?: GroupIdentifier[];
-    TagSpecifications?: SpotFleetTagSpecification[];
-    UserData?: string;
-    BlockDeviceMappings?: BlockDeviceMapping[];
-    IamInstanceProfile?: IamInstanceProfileSpecification;
-    KernelId?: string;
-    SubnetId?: string;
-    EbsOptimized?: boolean;
-    KeyName?: string;
-    RamdiskId?: string;
-    SpotPrice?: string;
-    WeightedCapacity?: number;
-    Placement?: SpotPlacement;
-    NetworkInterfaces?: InstanceNetworkInterfaceSpecification[];
-    ImageId: string;
-    InstanceRequirements?: InstanceRequirementsRequest;
-    InstanceType?: string;
-    Monitoring?: SpotFleetMonitoring;
+export interface BaselinePerformanceFactorsRequest {
+    Cpu?: CpuPerformanceFactorRequest;
 }
-export interface GroupIdentifier {
-    GroupId: string;
+export interface CpuPerformanceFactorRequest {
+    References?: PerformanceFactorReferenceRequest[];
 }
-export interface BlockDeviceMapping {
-    Ebs?: EbsBlockDevice;
-    NoDevice?: string;
-    VirtualName?: string;
-    DeviceName: string;
+export interface PerformanceFactorReferenceRequest {
+    InstanceFamily?: string;
 }
-export interface EbsBlockDevice {
-    SnapshotId?: string;
-    VolumeType?: ("gp2" | "gp3" | "io1" | "io2" | "sc1" | "st1" | "standard");
-    Encrypted?: boolean;
-    Iops?: number;
-    VolumeSize?: number;
-    DeleteOnTermination?: boolean;
+export interface LaunchTemplateConfig {
+    LaunchTemplateSpecification?: FleetLaunchTemplateSpecification;
+    Overrides?: LaunchTemplateOverrides[];
 }
-export interface IamInstanceProfileSpecification {
-    Arn?: string;
+export interface FleetLaunchTemplateSpecification {
+    LaunchTemplateId?: string;
+    LaunchTemplateName?: string;
+    Version: string;
 }
-export interface SpotPlacement {
-    GroupName?: string;
-    Tenancy?: ("dedicated" | "default" | "host");
+export interface LaunchTemplateOverrides {
     AvailabilityZone?: string;
-}
-export interface InstanceNetworkInterfaceSpecification {
-    Description?: string;
-    PrivateIpAddresses?: PrivateIpAddressSpecification[];
-    SecondaryPrivateIpAddressCount?: number;
-    DeviceIndex?: number;
-    Groups?: string[];
-    Ipv6AddressCount?: number;
-    Ipv6Addresses?: InstanceIpv6Address[];
+    AvailabilityZoneId?: string;
+    InstanceType?: string;
+    SpotPrice?: string;
     SubnetId?: string;
-    AssociatePublicIpAddress?: boolean;
-    NetworkInterfaceId?: string;
-    DeleteOnTermination?: boolean;
-}
-export interface PrivateIpAddressSpecification {
-    PrivateIpAddress: string;
-    Primary?: boolean;
-}
-export interface InstanceIpv6Address {
-    Ipv6Address: string;
-}
-export interface SpotFleetMonitoring {
-    Enabled?: boolean;
+    WeightedCapacity?: number;
+    InstanceRequirements?: InstanceRequirementsRequest;
+    Priority?: number;
 }
 export interface LoadBalancersConfig {
     ClassicLoadBalancersConfig?: ClassicLoadBalancersConfig;
@@ -224,3 +219,10 @@ export interface TargetGroupsConfig {
 export interface TargetGroup {
     Arn: string;
 }
+export interface SpotMaintenanceStrategies {
+    CapacityRebalance?: SpotCapacityRebalance;
+}
+export interface SpotCapacityRebalance {
+    ReplacementStrategy?: ("launch" | "launch-before-terminate");
+    TerminationDelay?: number;
+}

package/lib/types/cfn-resource-types/aws-ec2-spotfleet.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-spotfleet.js","sourceRoot":"","sources":["aws-ec2-spotfleet.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource Type definition for AWS::EC2::SpotFleet\n */\nexport interface _AWS_EC2_SPOTFLEET {\nSpotFleetRequestConfigData: SpotFleetRequestConfigData\nId?: string\n/**\n * The tags to specify in SpotFleetRequestConfigData\n */\nTags?: Tag[]\n}\nexport interface SpotFleetRequestConfigData {\nContext?: string\nSpotMaxTotalPrice?: string\nExcessCapacityTerminationPolicy?: (\"Default\" | \"NoTermination\" | \"default\" | \"noTermination\")\nTagSpecifications?: SpotFleetTagSpecification[]\nInstancePoolsToUseCount?: number\nLaunchTemplateConfigs?: LaunchTemplateConfig[]\nTargetCapacityUnitType?: (\"vcpu\" | \"memory-mib\" | \"units\")\nIamFleetRole: string\nSpotMaintenanceStrategies?: SpotMaintenanceStrategies\nTerminateInstancesWithExpiration?: boolean\nValidUntil?: string\nOnDemandMaxTotalPrice?: string\nOnDemandAllocationStrategy?: string\nSpotPrice?: string\nAllocationStrategy?: (\"capacityOptimized\" | \"capacityOptimizedPrioritized\" | \"diversified\" | \"lowestPrice\" | \"priceCapacityOptimized\")\nOnDemandTargetCapacity?: number\nType?: (\"maintain\" | \"request\")\nLaunchSpecifications?: SpotFleetLaunchSpecification[]\nInstanceInterruptionBehavior?: (\"hibernate\" | \"stop\" | \"terminate\")\nLoadBalancersConfig?: LoadBalancersConfig\nValidFrom?: string\nReplaceUnhealthyInstances?: boolean\nTargetCapacity: number\n}\nexport interface SpotFleetTagSpecification {\nResourceType?: (\"client-vpn-endpoint\" | \"customer-gateway\" | \"dedicated-host\" | \"dhcp-options\" | \"egress-only-internet-gateway\" | \"elastic-gpu\" | \"elastic-ip\" | \"export-image-task\" | \"export-instance-task\" | \"fleet\" | \"fpga-image\" | \"host-reservation\" | \"image\" | \"import-image-task\" | \"import-snapshot-task\" | \"instance\" | \"internet-gateway\" | \"key-pair\" | \"launch-template\" | \"local-gateway-route-table-vpc-association\" | \"natgateway\" | \"network-acl\" | \"network-insights-analysis\" | \"network-insights-path\" | \"network-interface\" | \"placement-group\" | \"reserved-instances\" | \"route-table\" | \"security-group\" | \"snapshot\" | \"spot-fleet-request\" | \"spot-instances-request\" | \"subnet\" | \"traffic-mirror-filter\" | \"traffic-mirror-session\" | \"traffic-mirror-target\" | \"transit-gateway\" | \"transit-gateway-attachment\" | \"transit-gateway-connect-peer\" | \"transit-gateway-multicast-domain\" | \"transit-gateway-route-table\" | \"volume\" | \"vpc\" | \"vpc-flow-log\" | \"vpc-peering-connection\" | \"vpn-connection\" | \"vpn-gateway\")\nTags?: Tag[]\n}\nexport interface Tag {\nValue: string\nKey: string\n}\nexport interface LaunchTemplateConfig {\nLaunchTemplateSpecification?: FleetLaunchTemplateSpecification\nOverrides?: LaunchTemplateOverrides[]\n}\nexport interface FleetLaunchTemplateSpecification {\nLaunchTemplateName?: string\nVersion: string\nLaunchTemplateId?: string\n}\nexport interface LaunchTemplateOverrides {\nSpotPrice?: string\nWeightedCapacity?: number\nPriority?: number\nAvailabilityZone?: string\nSubnetId?: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\n}\nexport interface InstanceRequirementsRequest {\nInstanceGenerations?: (\"current\" | \"previous\")[]\nRequireEncryptionInTransit?: boolean\nMemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest\nAcceleratorTypes?: (\"gpu\" | \"fpga\" | \"inference\" | \"media\")[]\nVCpuCount?: VCpuCountRangeRequest\nAcceleratorManufacturers?: (\"amazon-web-services\" | \"amd\" | \"habana\" | \"nvidia\" | \"xilinx\")[]\nLocalStorage?: (\"included\" | \"required\" | \"excluded\")\nCpuManufacturers?: (\"intel\" | \"amd\" | \"amazon-web-services\" | \"apple\")[]\nBareMetal?: (\"included\" | \"required\" | \"excluded\")\nRequireHibernateSupport?: boolean\nMaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number\nOnDemandMaxPricePercentageOverLowestPrice?: number\nMemoryMiB?: MemoryMiBRequest\nLocalStorageTypes?: (\"hdd\" | \"ssd\")[]\nNetworkInterfaceCount?: NetworkInterfaceCountRequest\nExcludedInstanceTypes?: string[]\nAllowedInstanceTypes?: string[]\nNetworkBandwidthGbps?: NetworkBandwidthGbpsRequest\nAcceleratorCount?: AcceleratorCountRequest\nBaselinePerformanceFactors?: BaselinePerformanceFactorsRequest\nSpotMaxPricePercentageOverLowestPrice?: number\nBaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest\nAcceleratorNames?: (\"a10g\" | \"a100\" | \"h100\" | \"inferentia\" | \"k520\" | \"k80\" | \"m60\" | \"radeon-pro-v520\" | \"t4\" | \"t4g\" | \"vu9p\" | \"v100\" | \"l40s\" | \"l4\" | \"gaudi-hl-205\" | \"inferentia2\" | \"trainium\" | \"trainium2\" | \"u30\")[]\nAcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest\nBurstablePerformance?: (\"included\" | \"required\" | \"excluded\")\nTotalLocalStorageGB?: TotalLocalStorageGBRequest\n}\nexport interface MemoryGiBPerVCpuRequest {\nMin?: number\nMax?: number\n}\nexport interface VCpuCountRangeRequest {\nMin?: number\nMax?: number\n}\nexport interface MemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkInterfaceCountRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkBandwidthGbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorCountRequest {\nMin?: number\nMax?: number\n}\nexport interface BaselinePerformanceFactorsRequest {\nCpu?: CpuPerformanceFactorRequest\n}\nexport interface CpuPerformanceFactorRequest {\nReferences?: PerformanceFactorReferenceRequest[]\n}\nexport interface PerformanceFactorReferenceRequest {\nInstanceFamily?: string\n}\nexport interface BaselineEbsBandwidthMbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorTotalMemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface TotalLocalStorageGBRequest {\nMin?: number\nMax?: number\n}\nexport interface SpotMaintenanceStrategies {\nCapacityRebalance?: SpotCapacityRebalance\n}\nexport interface SpotCapacityRebalance {\nTerminationDelay?: number\nReplacementStrategy?: (\"launch\" | \"launch-before-terminate\")\n}\nexport interface SpotFleetLaunchSpecification {\nSecurityGroups?: GroupIdentifier[]\nTagSpecifications?: SpotFleetTagSpecification[]\nUserData?: string\nBlockDeviceMappings?: BlockDeviceMapping[]\nIamInstanceProfile?: IamInstanceProfileSpecification\nKernelId?: string\nSubnetId?: string\nEbsOptimized?: boolean\nKeyName?: string\nRamdiskId?: string\nSpotPrice?: string\nWeightedCapacity?: number\nPlacement?: SpotPlacement\nNetworkInterfaces?: InstanceNetworkInterfaceSpecification[]\nImageId: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\nMonitoring?: SpotFleetMonitoring\n}\nexport interface GroupIdentifier {\nGroupId: string\n}\nexport interface BlockDeviceMapping {\nEbs?: EbsBlockDevice\nNoDevice?: string\nVirtualName?: string\nDeviceName: string\n}\nexport interface EbsBlockDevice {\nSnapshotId?: string\nVolumeType?: (\"gp2\" | \"gp3\" | \"io1\" | \"io2\" | \"sc1\" | \"st1\" | \"standard\")\nEncrypted?: boolean\nIops?: number\nVolumeSize?: number\nDeleteOnTermination?: boolean\n}\nexport interface IamInstanceProfileSpecification {\nArn?: string\n}\nexport interface SpotPlacement {\nGroupName?: string\nTenancy?: (\"dedicated\" | \"default\" | \"host\")\nAvailabilityZone?: string\n}\nexport interface InstanceNetworkInterfaceSpecification {\nDescription?: string\nPrivateIpAddresses?: PrivateIpAddressSpecification[]\nSecondaryPrivateIpAddressCount?: number\nDeviceIndex?: number\nGroups?: string[]\nIpv6AddressCount?: number\nIpv6Addresses?: InstanceIpv6Address[]\nSubnetId?: string\nAssociatePublicIpAddress?: boolean\nNetworkInterfaceId?: string\nDeleteOnTermination?: boolean\n}\nexport interface PrivateIpAddressSpecification {\nPrivateIpAddress: string\nPrimary?: boolean\n}\nexport interface InstanceIpv6Address {\nIpv6Address: string\n}\nexport interface SpotFleetMonitoring {\nEnabled?: boolean\n}\nexport interface LoadBalancersConfig {\nClassicLoadBalancersConfig?: ClassicLoadBalancersConfig\nTargetGroupsConfig?: TargetGroupsConfig\n}\nexport interface ClassicLoadBalancersConfig {\nClassicLoadBalancers: ClassicLoadBalancer[]\n}\nexport interface ClassicLoadBalancer {\nName: string\n}\nexport interface TargetGroupsConfig {\nTargetGroups: TargetGroup[]\n}\nexport interface TargetGroup {\nArn: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-spotfleet.js","sourceRoot":"","sources":["aws-ec2-spotfleet.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource Type definition for AWS::EC2::SpotFleet\n */\nexport interface _AWS_EC2_SPOTFLEET {\nId?: string\nSpotFleetRequestConfigData: SpotFleetRequestConfigData\n/**\n * The tags to specify in SpotFleetRequestConfigData\n */\nTags?: Tag[]\n}\nexport interface SpotFleetRequestConfigData {\nAllocationStrategy?: (\"capacityOptimized\" | \"capacityOptimizedPrioritized\" | \"diversified\" | \"lowestPrice\" | \"priceCapacityOptimized\")\nContext?: string\nExcessCapacityTerminationPolicy?: (\"Default\" | \"NoTermination\" | \"default\" | \"noTermination\")\nIamFleetRole: string\nInstanceInterruptionBehavior?: (\"hibernate\" | \"stop\" | \"terminate\")\nInstancePoolsToUseCount?: number\nLaunchSpecifications?: SpotFleetLaunchSpecification[]\nLaunchTemplateConfigs?: LaunchTemplateConfig[]\nLoadBalancersConfig?: LoadBalancersConfig\nOnDemandAllocationStrategy?: string\nOnDemandMaxTotalPrice?: string\nOnDemandTargetCapacity?: number\nReplaceUnhealthyInstances?: boolean\nSpotMaintenanceStrategies?: SpotMaintenanceStrategies\nSpotMaxTotalPrice?: string\nSpotPrice?: string\nTargetCapacity: number\nTerminateInstancesWithExpiration?: boolean\nType?: (\"maintain\" | \"request\")\nValidFrom?: string\nValidUntil?: string\nTagSpecifications?: SpotFleetTagSpecification[]\nTargetCapacityUnitType?: (\"vcpu\" | \"memory-mib\" | \"units\")\n}\nexport interface SpotFleetLaunchSpecification {\nBlockDeviceMappings?: BlockDeviceMapping[]\nEbsOptimized?: boolean\nIamInstanceProfile?: IamInstanceProfileSpecification\nImageId: string\nInstanceType?: string\nKernelId?: string\nKeyName?: string\nMonitoring?: SpotFleetMonitoring\nNetworkInterfaces?: InstanceNetworkInterfaceSpecification[]\nPlacement?: SpotPlacement\nRamdiskId?: string\nSecurityGroups?: GroupIdentifier[]\nSpotPrice?: string\nSubnetId?: string\nTagSpecifications?: SpotFleetTagSpecification[]\nUserData?: string\nWeightedCapacity?: number\nInstanceRequirements?: InstanceRequirementsRequest\n}\nexport interface BlockDeviceMapping {\nDeviceName: string\nEbs?: EbsBlockDevice\nNoDevice?: string\nVirtualName?: string\n}\nexport interface EbsBlockDevice {\nDeleteOnTermination?: boolean\nEncrypted?: boolean\nIops?: number\nSnapshotId?: string\nVolumeSize?: number\nVolumeType?: (\"gp2\" | \"gp3\" | \"io1\" | \"io2\" | \"sc1\" | \"st1\" | \"standard\")\n}\nexport interface IamInstanceProfileSpecification {\nArn?: string\n}\nexport interface SpotFleetMonitoring {\nEnabled?: boolean\n}\nexport interface InstanceNetworkInterfaceSpecification {\nAssociatePublicIpAddress?: boolean\nDeleteOnTermination?: boolean\nDescription?: string\nDeviceIndex?: number\nGroups?: string[]\nIpv6AddressCount?: number\nIpv6Addresses?: InstanceIpv6Address[]\nNetworkInterfaceId?: string\nPrivateIpAddresses?: PrivateIpAddressSpecification[]\nSecondaryPrivateIpAddressCount?: number\nSubnetId?: string\n}\nexport interface InstanceIpv6Address {\nIpv6Address: string\n}\nexport interface PrivateIpAddressSpecification {\nPrimary?: boolean\nPrivateIpAddress: string\n}\nexport interface SpotPlacement {\nAvailabilityZone?: string\nAvailabilityZoneId?: string\nGroupName?: string\nTenancy?: (\"dedicated\" | \"default\" | \"host\")\n}\nexport interface GroupIdentifier {\nGroupId: string\n}\nexport interface SpotFleetTagSpecification {\nResourceType?: (\"client-vpn-endpoint\" | \"customer-gateway\" | \"dedicated-host\" | \"dhcp-options\" | \"egress-only-internet-gateway\" | \"elastic-gpu\" | \"elastic-ip\" | \"export-image-task\" | \"export-instance-task\" | \"fleet\" | \"fpga-image\" | \"host-reservation\" | \"image\" | \"import-image-task\" | \"import-snapshot-task\" | \"instance\" | \"internet-gateway\" | \"key-pair\" | \"launch-template\" | \"local-gateway-route-table-vpc-association\" | \"natgateway\" | \"network-acl\" | \"network-insights-analysis\" | \"network-insights-path\" | \"network-interface\" | \"placement-group\" | \"reserved-instances\" | \"route-table\" | \"security-group\" | \"snapshot\" | \"spot-fleet-request\" | \"spot-instances-request\" | \"subnet\" | \"traffic-mirror-filter\" | \"traffic-mirror-session\" | \"traffic-mirror-target\" | \"transit-gateway\" | \"transit-gateway-attachment\" | \"transit-gateway-connect-peer\" | \"transit-gateway-multicast-domain\" | \"transit-gateway-route-table\" | \"volume\" | \"vpc\" | \"vpc-flow-log\" | \"vpc-peering-connection\" | \"vpn-connection\" | \"vpn-gateway\")\nTags?: Tag[]\n}\nexport interface Tag {\nKey: string\nValue: string\n}\nexport interface InstanceRequirementsRequest {\nVCpuCount?: VCpuCountRangeRequest\nMemoryMiB?: MemoryMiBRequest\nCpuManufacturers?: (\"intel\" | \"amd\" | \"amazon-web-services\" | \"apple\")[]\nMemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest\nAllowedInstanceTypes?: string[]\nExcludedInstanceTypes?: string[]\nInstanceGenerations?: (\"current\" | \"previous\")[]\nSpotMaxPricePercentageOverLowestPrice?: number\nOnDemandMaxPricePercentageOverLowestPrice?: number\nMaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number\nBareMetal?: (\"included\" | \"required\" | \"excluded\")\nBurstablePerformance?: (\"included\" | \"required\" | \"excluded\")\nRequireHibernateSupport?: boolean\nNetworkBandwidthGbps?: NetworkBandwidthGbpsRequest\nNetworkInterfaceCount?: NetworkInterfaceCountRequest\nLocalStorage?: (\"included\" | \"required\" | \"excluded\")\nLocalStorageTypes?: (\"hdd\" | \"ssd\")[]\nTotalLocalStorageGB?: TotalLocalStorageGBRequest\nBaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest\nAcceleratorTypes?: (\"gpu\" | \"fpga\" | \"inference\" | \"media\")[]\nAcceleratorCount?: AcceleratorCountRequest\nAcceleratorManufacturers?: (\"amazon-web-services\" | \"amd\" | \"habana\" | \"nvidia\" | \"xilinx\")[]\nAcceleratorNames?: (\"a10g\" | \"a100\" | \"h100\" | \"inferentia\" | \"k520\" | \"k80\" | \"m60\" | \"radeon-pro-v520\" | \"t4\" | \"t4g\" | \"vu9p\" | \"v100\" | \"l40s\" | \"l4\" | \"gaudi-hl-205\" | \"inferentia2\" | \"trainium\" | \"trainium2\" | \"u30\")[]\nAcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest\nBaselinePerformanceFactors?: BaselinePerformanceFactorsRequest\nRequireEncryptionInTransit?: boolean\n}\nexport interface VCpuCountRangeRequest {\nMin?: number\nMax?: number\n}\nexport interface MemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface MemoryGiBPerVCpuRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkBandwidthGbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkInterfaceCountRequest {\nMin?: number\nMax?: number\n}\nexport interface TotalLocalStorageGBRequest {\nMin?: number\nMax?: number\n}\nexport interface BaselineEbsBandwidthMbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorCountRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorTotalMemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface BaselinePerformanceFactorsRequest {\nCpu?: CpuPerformanceFactorRequest\n}\nexport interface CpuPerformanceFactorRequest {\nReferences?: PerformanceFactorReferenceRequest[]\n}\nexport interface PerformanceFactorReferenceRequest {\nInstanceFamily?: string\n}\nexport interface LaunchTemplateConfig {\nLaunchTemplateSpecification?: FleetLaunchTemplateSpecification\nOverrides?: LaunchTemplateOverrides[]\n}\nexport interface FleetLaunchTemplateSpecification {\nLaunchTemplateId?: string\nLaunchTemplateName?: string\nVersion: string\n}\nexport interface LaunchTemplateOverrides {\nAvailabilityZone?: string\nAvailabilityZoneId?: string\nInstanceType?: string\nSpotPrice?: string\nSubnetId?: string\nWeightedCapacity?: number\nInstanceRequirements?: InstanceRequirementsRequest\nPriority?: number\n}\nexport interface LoadBalancersConfig {\nClassicLoadBalancersConfig?: ClassicLoadBalancersConfig\nTargetGroupsConfig?: TargetGroupsConfig\n}\nexport interface ClassicLoadBalancersConfig {\nClassicLoadBalancers: ClassicLoadBalancer[]\n}\nexport interface ClassicLoadBalancer {\nName: string\n}\nexport interface TargetGroupsConfig {\nTargetGroups: TargetGroup[]\n}\nexport interface TargetGroup {\nArn: string\n}\nexport interface SpotMaintenanceStrategies {\nCapacityRebalance?: SpotCapacityRebalance\n}\nexport interface SpotCapacityRebalance {\nReplacementStrategy?: (\"launch\" | \"launch-before-terminate\")\nTerminationDelay?: number\n}\n"]}

package/lib/types/cfn-resource-types/aws-ec2-volume.d.ts

@@ -1,13 +1,13 @@
 /**
- * Specifies an Amazon Elastic Block Store (Amazon EBS) volume.
- *  When you use CFNlong to update an Amazon EBS volume that modifies ``Iops``, ``Size``, or ``VolumeType``, there is a cooldown period before another operation can occur. This can cause your stack to report being in ``UPDATE_IN_PROGRESS`` or ``UPDATE_ROLLBACK_IN_PROGRESS`` for long periods of time.
- *  Amazon EBS does not support sizing down an Amazon EBS volume. CFNlong does not attempt to modify an Amazon EBS volume to a smaller size on rollback.
- *  Some common scenarios when you might encounter a cooldown period for Amazon EBS include:
+ * Specifies an Amazon Elastic Block Store (Amazon EBS) volume. You can create an empty volume, a volume from a snapshot, or a volume copy from an existing source volume.
+ *    +  When you use CFNlong to update an Amazon EBS volume that modifies ``Iops``, ``Size``, or ``VolumeType``, there is a cooldown period before another operation can occur. This can cause your stack to report being in ``UPDATE_IN_PROGRESS`` or ``UPDATE_ROLLBACK_IN_PROGRESS`` for long periods of time. Some common scenarios when you might encounter a cooldown period for Amazon EBS include:
  *   +  You successfully update an Amazon EBS volume and the update succeeds. When you attempt another update within the cooldown window, that update will be subject to a cooldown period.
  *   +  You successfully update an Amazon EBS volume and the update succeeds but another change in your ``update-stack`` call fails. The rollback will be subject to a cooldown period.
  *
  *  For more information, see [Requirements for EBS volume modifications](https://docs.aws.amazon.com/ebs/latest/userguide/modify-volume-requirements.html).
- *   *DeletionPolicy attribute*
+ *   +  Amazon EBS does not support sizing down an Amazon EBS volume. CFNlong does not attempt to modify an Amazon EBS volume to a smaller size on rollback.
+ *
+ *    *DeletionPolicy attribute*
  *  To control how CFNlong handles the volume when the stack is deleted, set a deletion policy for your volume. You can choose to retain the volume, to delete the volume, or to create a snapshot of the volume. For more information, see [DeletionPolicy attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html).
  *   If you set a deletion policy that creates a snapshot, all tags on the volume are included in the snapshot.
  */
@@ -27,16 +27,21 @@ export type _AWS_EC2_VOLUME = ({
      *   +  Key alias. Specify the alias for the key, prefixed with ``alias/``. For example, for a key with the alias ``my_cmk``, use ``alias/my_cmk``. Or to specify the aws-managed-key, use ``alias/aws/ebs``.
      *   +  Key ARN. For example, arn:aws:kms:us-east-1:012345678910:key/1234abcd-12ab-34cd-56ef-1234567890ab.
      *   +  Alias ARN. For example, arn:aws:kms:us-east-1:012345678910:alias/ExampleAlias.
+     *
+     *  If you are creating a volume copy, omit this parameter. The volume is automatically encrypted with the same KMS key as the source volume. You can't copy unencrypted volumes.
      */
     KmsKeyId?: string;
     /**
-     * Indicates whether the volume should be encrypted. The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see [Encryption by default](https://docs.aws.amazon.com/ebs/latest/userguide/work-with-ebs-encr.html#encryption-by-default) in the *Amazon EBS User Guide*.
-     *  Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see [Supported instance types](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption-requirements.html#ebs-encryption_supported_instances).
+     * Indicates whether the volume should be encrypted. The effect of setting the encryption state to ``true`` depends on the volume origin (new, from a snapshot, or from an existing volume), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see [Encryption by default](https://docs.aws.amazon.com/ebs/latest/userguide/work-with-ebs-encr.html#encryption-by-default) in the *Amazon EBS User Guide*.
+     *  If you are creating a volume copy, omit this parameter. The volume is automatically encrypted with the same KMS key as the source volume. You can't copy unencrypted volumes.
      */
     Encrypted?: boolean;
     /**
-     * The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size, and you can specify a volume size that is equal to or larger than the snapshot size.
-     *  Valid sizes:
+     * The size of the volume, in GiBs.
+     *   +  Required for new empty volumes.
+     *   +  Optional for volumes created from snapshots and volume copies. In this case, the size defaults to the size of the snapshot or source volume. You can optionally specify a size that is equal to or larger than the size of the source snapshot or volume.
+     *
+     *  Supported volume sizes:
      *   +  gp2: ``1 - 16,384`` GiB
      *   +  gp3: ``1 - 65,536`` GiB
      *   +  io1: ``4 - 16,384`` GiB
@@ -46,18 +51,25 @@ export type _AWS_EC2_VOLUME = ({
      */
     Size?: number;
     /**
-     * Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.
+     * Indicates whether the volume is auto-enabled for I/O operations. By default, EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.
      */
     AutoEnableIO?: boolean;
     /**
-     * The Amazon Resource Name (ARN) of the Outpost.
+     * The Amazon Resource Name (ARN) of the Outpost on which to create the volume.
+     *  If you intend to use a volume with an instance running on an outpost, then you must create the volume on the same outpost as the instance. You can't use a volume created in an AWS Region with an instance on an AWS outpost, or the other way around.
      */
     OutpostArn?: string;
     /**
      * The ID of the Availability Zone in which to create the volume. For example, ``us-east-1a``.
      *  Either ``AvailabilityZone`` or ``AvailabilityZoneId`` must be specified, but not both.
+     *  If you are creating a volume copy, omit this parameter. The volume copy is created in the same Availability Zone as the source volume.
      */
     AvailabilityZone?: string;
+    /**
+     * The ID of the Availability Zone in which to create the volume. For example, ``use1-az1``.
+     *  Either ``AvailabilityZone`` or ``AvailabilityZoneId`` must be specified, but not both.
+     *  If you are creating a volume copy, omit this parameter. The volume copy is created in the same Availability Zone as the source volume.
+     */
     AvailabilityZoneId?: string;
     /**
      * The throughput to provision for a volume, with a maximum of 1,000 MiB/s.
@@ -76,9 +88,12 @@ export type _AWS_EC2_VOLUME = ({
      */
     Iops?: number;
     /**
-     * The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size.
+     * The snapshot from which to create the volume. Only specify to create a volume from a snapshot. To create a new empty volume, omit this parameter and specify a value for ``Size`` instead. To create a volume copy, omit this parameter and specify ``SourceVolumeId`` instead.
      */
     SnapshotId?: string;
+    /**
+     * The ID of the source EBS volume to copy. When specified, the volume is created as an exact copy of the specified volume. Only specify to create a volume copy. To create a new empty volume or to create a volume from a snapshot, omit this parameter,
+     */
     SourceVolumeId?: string;
     /**
      * The volume type. This parameter can be one of the following values:
@@ -88,7 +103,8 @@ export type _AWS_EC2_VOLUME = ({
      *   +  Cold HDD: ``sc1``
      *   +  Magnetic: ``standard``
      *
-     *  For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volume-types.html).
+     *   Throughput Optimized HDD (``st1``) and Cold HDD (``sc1``) volumes can't be used as boot volumes.
+     *   For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volume-types.html) in the *Amazon EBS User Guide*.
      *  Default: ``gp2``
      */
     VolumeType?: string;

package/lib/types/cfn-resource-types/aws-ec2-volume.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-volume.js","sourceRoot":"","sources":["aws-ec2-volume.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Specifies an Amazon Elastic Block Store (Amazon EBS) volume.\n *  When you use CFNlong to update an Amazon EBS volume that modifies ``Iops``, ``Size``, or ``VolumeType``, there is a cooldown period before another operation can occur. This can cause your stack to report being in ``UPDATE_IN_PROGRESS`` or ``UPDATE_ROLLBACK_IN_PROGRESS`` for long periods of time.\n *  Amazon EBS does not support sizing down an Amazon EBS volume. CFNlong does not attempt to modify an Amazon EBS volume to a smaller size on rollback.\n *  Some common scenarios when you might encounter a cooldown period for Amazon EBS include:\n *   +  You successfully update an Amazon EBS volume and the update succeeds. When you attempt another update within the cooldown window, that update will be subject to a cooldown period.\n *   +  You successfully update an Amazon EBS volume and the update succeeds but another change in your ``update-stack`` call fails. The rollback will be subject to a cooldown period.\n *   \n *  For more information, see [Requirements for EBS volume modifications](https://docs.aws.amazon.com/ebs/latest/userguide/modify-volume-requirements.html).\n *   *DeletionPolicy attribute* \n *  To control how CFNlong handles the volume when the stack is deleted, set a deletion policy for your volume. You can choose to retain the volume, to delete the volume, or to create a snapshot of the volume. For more information, see [DeletionPolicy attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html).\n *   If you set a deletion policy that creates a snapshot, all tags on the volume are included in the snapshot.\n */\nexport type _AWS_EC2_VOLUME = ({\n[k: string]: unknown\n} & {\n/**\n * Indicates whether Amazon EBS Multi-Attach is enabled.\n *  CFNlong does not currently support updating a single-attach volume to be multi-attach enabled, updating a multi-attach enabled volume to be single-attach, or updating the size or number of I/O operations per second (IOPS) of a multi-attach enabled volume.\n */\nMultiAttachEnabled?: boolean\n/**\n * The identifier of the kms-key-long to use for Amazon EBS encryption. If ``KmsKeyId`` is specified, the encrypted state must be ``true``.\n *  If you omit this property and your account is enabled for encryption by default, or *Encrypted* is set to ``true``, then the volume is encrypted using the default key specified for your account. If your account does not have a default key, then the volume is encrypted using the aws-managed-key.\n *  Alternatively, if you want to specify a different key, you can specify one of the following:\n *   +  Key ID. For example, 1234abcd-12ab-34cd-56ef-1234567890ab.\n *   +  Key alias. Specify the alias for the key, prefixed with ``alias/``. For example, for a key with the alias ``my_cmk``, use ``alias/my_cmk``. Or to specify the aws-managed-key, use ``alias/aws/ebs``.\n *   +  Key ARN. For example, arn:aws:kms:us-east-1:012345678910:key/1234abcd-12ab-34cd-56ef-1234567890ab.\n *   +  Alias ARN. For example, arn:aws:kms:us-east-1:012345678910:alias/ExampleAlias.\n */\nKmsKeyId?: string\n/**\n * Indicates whether the volume should be encrypted. The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see [Encryption by default](https://docs.aws.amazon.com/ebs/latest/userguide/work-with-ebs-encr.html#encryption-by-default) in the *Amazon EBS User Guide*.\n *  Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see [Supported instance types](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption-requirements.html#ebs-encryption_supported_instances).\n */\nEncrypted?: boolean\n/**\n * The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size, and you can specify a volume size that is equal to or larger than the snapshot size.\n *  Valid sizes:\n *   +  gp2: ``1 - 16,384`` GiB\n *   +  gp3: ``1 - 65,536`` GiB\n *   +  io1: ``4 - 16,384`` GiB\n *   +  io2: ``4 - 65,536`` GiB\n *   +  st1 and sc1: ``125 - 16,384`` GiB\n *   +  standard: ``1 - 1024`` GiB\n */\nSize?: number\n/**\n * Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.\n */\nAutoEnableIO?: boolean\n/**\n * The Amazon Resource Name (ARN) of the Outpost.\n */\nOutpostArn?: string\n/**\n * The ID of the Availability Zone in which to create the volume. For example, ``us-east-1a``.\n *  Either ``AvailabilityZone`` or ``AvailabilityZoneId`` must be specified, but not both.\n */\nAvailabilityZone?: string\nAvailabilityZoneId?: string\n/**\n * The throughput to provision for a volume, with a maximum of 1,000 MiB/s.\n *  This parameter is valid only for ``gp3`` volumes. The default value is 125.\n *  Valid Range: Minimum value of 125. Maximum value of 1000.\n */\nThroughput?: number\n/**\n * The number of I/O operations per second (IOPS) to provision for the volume. Required for ``io1`` and ``io2`` volumes. Optional for ``gp3`` volumes. Omit for all other volume types. \n *  Valid ranges:\n *   +  gp3: ``3,000``(*default*)``- 80,000`` IOPS\n *   +  io1: ``100 - 64,000`` IOPS\n *   +  io2: ``100 - 256,000`` IOPS\n *   \n *   [Instances built on the Nitro System](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html) can support up to 256,000 IOPS. Other instances can support up to 32,000 IOPS.\n */\nIops?: number\n/**\n * The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size.\n */\nSnapshotId?: string\nSourceVolumeId?: string\n/**\n * The volume type. This parameter can be one of the following values:\n *   +  General Purpose SSD: ``gp2`` | ``gp3``\n *   +  Provisioned IOPS SSD: ``io1`` | ``io2``\n *   +  Throughput Optimized HDD: ``st1``\n *   +  Cold HDD: ``sc1``\n *   +  Magnetic: ``standard``\n *   \n *  For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volume-types.html).\n *  Default: ``gp2``\n */\nVolumeType?: string\nVolumeId?: string\n/**\n * The tags to apply to the volume during creation.\n */\nTags?: Tag[]\n/**\n * Specifies the Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate), in MiB/s, at which to download the snapshot blocks from Amazon S3 to the volume. This is also known as *volume initialization*. Specifying a volume initialization rate ensures that the volume is initialized at a predictable and consistent rate after creation.\n *  This parameter is supported only for volumes created from snapshots. Omit this parameter if:\n *   +  You want to create the volume using fast snapshot restore. You must specify a snapshot that is enabled for fast snapshot restore. In this case, the volume is fully initialized at creation.\n *   If you specify a snapshot that is enabled for fast snapshot restore and a volume initialization rate, the volume will be initialized at the specified rate instead of fast snapshot restore.\n *    +  You want to create a volume that is initialized at the default rate.\n *   \n *  For more information, see [Initialize Amazon EBS volumes](https://docs.aws.amazon.com/ebs/latest/userguide/initalize-volume.html) in the *Amazon EC2 User Guide*.\n *  Valid range: 100 - 300 MiB/s\n */\nVolumeInitializationRate?: number\n})\n\n/**\n * Specifies a tag. For more information, see [Resource tags](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html).\n */\nexport interface Tag {\n/**\n * The tag key.\n */\nKey: string\n/**\n * The tag value.\n */\nValue: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-volume.js","sourceRoot":"","sources":["aws-ec2-volume.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Specifies an Amazon Elastic Block Store (Amazon EBS) volume. You can create an empty volume, a volume from a snapshot, or a volume copy from an existing source volume.\n *    +  When you use CFNlong to update an Amazon EBS volume that modifies ``Iops``, ``Size``, or ``VolumeType``, there is a cooldown period before another operation can occur. This can cause your stack to report being in ``UPDATE_IN_PROGRESS`` or ``UPDATE_ROLLBACK_IN_PROGRESS`` for long periods of time. Some common scenarios when you might encounter a cooldown period for Amazon EBS include:\n *   +  You successfully update an Amazon EBS volume and the update succeeds. When you attempt another update within the cooldown window, that update will be subject to a cooldown period.\n *   +  You successfully update an Amazon EBS volume and the update succeeds but another change in your ``update-stack`` call fails. The rollback will be subject to a cooldown period.\n *   \n *  For more information, see [Requirements for EBS volume modifications](https://docs.aws.amazon.com/ebs/latest/userguide/modify-volume-requirements.html).\n *   +  Amazon EBS does not support sizing down an Amazon EBS volume. CFNlong does not attempt to modify an Amazon EBS volume to a smaller size on rollback.\n *   \n *    *DeletionPolicy attribute* \n *  To control how CFNlong handles the volume when the stack is deleted, set a deletion policy for your volume. You can choose to retain the volume, to delete the volume, or to create a snapshot of the volume. For more information, see [DeletionPolicy attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html).\n *   If you set a deletion policy that creates a snapshot, all tags on the volume are included in the snapshot.\n */\nexport type _AWS_EC2_VOLUME = ({\n[k: string]: unknown\n} & {\n/**\n * Indicates whether Amazon EBS Multi-Attach is enabled.\n *  CFNlong does not currently support updating a single-attach volume to be multi-attach enabled, updating a multi-attach enabled volume to be single-attach, or updating the size or number of I/O operations per second (IOPS) of a multi-attach enabled volume.\n */\nMultiAttachEnabled?: boolean\n/**\n * The identifier of the kms-key-long to use for Amazon EBS encryption. If ``KmsKeyId`` is specified, the encrypted state must be ``true``.\n *  If you omit this property and your account is enabled for encryption by default, or *Encrypted* is set to ``true``, then the volume is encrypted using the default key specified for your account. If your account does not have a default key, then the volume is encrypted using the aws-managed-key.\n *  Alternatively, if you want to specify a different key, you can specify one of the following:\n *   +  Key ID. For example, 1234abcd-12ab-34cd-56ef-1234567890ab.\n *   +  Key alias. Specify the alias for the key, prefixed with ``alias/``. For example, for a key with the alias ``my_cmk``, use ``alias/my_cmk``. Or to specify the aws-managed-key, use ``alias/aws/ebs``.\n *   +  Key ARN. For example, arn:aws:kms:us-east-1:012345678910:key/1234abcd-12ab-34cd-56ef-1234567890ab.\n *   +  Alias ARN. For example, arn:aws:kms:us-east-1:012345678910:alias/ExampleAlias.\n *   \n *  If you are creating a volume copy, omit this parameter. The volume is automatically encrypted with the same KMS key as the source volume. You can't copy unencrypted volumes.\n */\nKmsKeyId?: string\n/**\n * Indicates whether the volume should be encrypted. The effect of setting the encryption state to ``true`` depends on the volume origin (new, from a snapshot, or from an existing volume), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see [Encryption by default](https://docs.aws.amazon.com/ebs/latest/userguide/work-with-ebs-encr.html#encryption-by-default) in the *Amazon EBS User Guide*.\n *  If you are creating a volume copy, omit this parameter. The volume is automatically encrypted with the same KMS key as the source volume. You can't copy unencrypted volumes.\n */\nEncrypted?: boolean\n/**\n * The size of the volume, in GiBs.\n *   +  Required for new empty volumes.\n *   +  Optional for volumes created from snapshots and volume copies. In this case, the size defaults to the size of the snapshot or source volume. You can optionally specify a size that is equal to or larger than the size of the source snapshot or volume.\n *   \n *  Supported volume sizes:\n *   +  gp2: ``1 - 16,384`` GiB\n *   +  gp3: ``1 - 65,536`` GiB\n *   +  io1: ``4 - 16,384`` GiB\n *   +  io2: ``4 - 65,536`` GiB\n *   +  st1 and sc1: ``125 - 16,384`` GiB\n *   +  standard: ``1 - 1024`` GiB\n */\nSize?: number\n/**\n * Indicates whether the volume is auto-enabled for I/O operations. By default, EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.\n */\nAutoEnableIO?: boolean\n/**\n * The Amazon Resource Name (ARN) of the Outpost on which to create the volume.\n *  If you intend to use a volume with an instance running on an outpost, then you must create the volume on the same outpost as the instance. You can't use a volume created in an AWS Region with an instance on an AWS outpost, or the other way around.\n */\nOutpostArn?: string\n/**\n * The ID of the Availability Zone in which to create the volume. For example, ``us-east-1a``.\n *  Either ``AvailabilityZone`` or ``AvailabilityZoneId`` must be specified, but not both.\n *  If you are creating a volume copy, omit this parameter. The volume copy is created in the same Availability Zone as the source volume.\n */\nAvailabilityZone?: string\n/**\n * The ID of the Availability Zone in which to create the volume. For example, ``use1-az1``.\n *  Either ``AvailabilityZone`` or ``AvailabilityZoneId`` must be specified, but not both.\n *  If you are creating a volume copy, omit this parameter. The volume copy is created in the same Availability Zone as the source volume.\n */\nAvailabilityZoneId?: string\n/**\n * The throughput to provision for a volume, with a maximum of 1,000 MiB/s.\n *  This parameter is valid only for ``gp3`` volumes. The default value is 125.\n *  Valid Range: Minimum value of 125. Maximum value of 1000.\n */\nThroughput?: number\n/**\n * The number of I/O operations per second (IOPS) to provision for the volume. Required for ``io1`` and ``io2`` volumes. Optional for ``gp3`` volumes. Omit for all other volume types. \n *  Valid ranges:\n *   +  gp3: ``3,000``(*default*)``- 80,000`` IOPS\n *   +  io1: ``100 - 64,000`` IOPS\n *   +  io2: ``100 - 256,000`` IOPS\n *   \n *   [Instances built on the Nitro System](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html) can support up to 256,000 IOPS. Other instances can support up to 32,000 IOPS.\n */\nIops?: number\n/**\n * The snapshot from which to create the volume. Only specify to create a volume from a snapshot. To create a new empty volume, omit this parameter and specify a value for ``Size`` instead. To create a volume copy, omit this parameter and specify ``SourceVolumeId`` instead.\n */\nSnapshotId?: string\n/**\n * The ID of the source EBS volume to copy. When specified, the volume is created as an exact copy of the specified volume. Only specify to create a volume copy. To create a new empty volume or to create a volume from a snapshot, omit this parameter,\n */\nSourceVolumeId?: string\n/**\n * The volume type. This parameter can be one of the following values:\n *   +  General Purpose SSD: ``gp2`` | ``gp3``\n *   +  Provisioned IOPS SSD: ``io1`` | ``io2``\n *   +  Throughput Optimized HDD: ``st1``\n *   +  Cold HDD: ``sc1``\n *   +  Magnetic: ``standard``\n *   \n *   Throughput Optimized HDD (``st1``) and Cold HDD (``sc1``) volumes can't be used as boot volumes.\n *   For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volume-types.html) in the *Amazon EBS User Guide*.\n *  Default: ``gp2``\n */\nVolumeType?: string\nVolumeId?: string\n/**\n * The tags to apply to the volume during creation.\n */\nTags?: Tag[]\n/**\n * Specifies the Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate), in MiB/s, at which to download the snapshot blocks from Amazon S3 to the volume. This is also known as *volume initialization*. Specifying a volume initialization rate ensures that the volume is initialized at a predictable and consistent rate after creation.\n *  This parameter is supported only for volumes created from snapshots. Omit this parameter if:\n *   +  You want to create the volume using fast snapshot restore. You must specify a snapshot that is enabled for fast snapshot restore. In this case, the volume is fully initialized at creation.\n *   If you specify a snapshot that is enabled for fast snapshot restore and a volume initialization rate, the volume will be initialized at the specified rate instead of fast snapshot restore.\n *    +  You want to create a volume that is initialized at the default rate.\n *   \n *  For more information, see [Initialize Amazon EBS volumes](https://docs.aws.amazon.com/ebs/latest/userguide/initalize-volume.html) in the *Amazon EC2 User Guide*.\n *  Valid range: 100 - 300 MiB/s\n */\nVolumeInitializationRate?: number\n})\n\n/**\n * Specifies a tag. For more information, see [Resource tags](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html).\n */\nexport interface Tag {\n/**\n * The tag key.\n */\nKey: string\n/**\n * The tag value.\n */\nValue: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-ec2-vpnconcentrator.d.ts

@@ -1,21 +1,15 @@
 /**
- * Resource Type definition for AWS::EC2::VPNConcentrator
+ * Describes a VPN concentrator.
  */
 export interface _AWS_EC2_VPNCONCENTRATOR {
-    /**
-     * The provider-assigned unique ID for this managed resource
-     */
     VpnConcentratorId?: string;
     /**
-     * The ID of the transit gateway
+     * The ID of the transit gateway associated with the VPN concentrator.
      */
     TransitGatewayId: string;
-    /**
-     * The ID of the transit gateway attachment
-     */
     TransitGatewayAttachmentId?: string;
     /**
-     * The type of VPN concentrator
+     * The type of VPN concentrator.
      */
     Type: string;
     /**
@@ -23,7 +17,18 @@ export interface _AWS_EC2_VPNCONCENTRATOR {
      */
     Tags?: Tag[];
 }
+/**
+ * Describes a tag.
+ */
 export interface Tag {
+    /**
+     * The key of the tag.
+     *  Constraints: Tag keys are case-sensitive and accept a maximum of 127 Unicode characters. May not begin with ``aws:``.
+     */
     Key: string;
+    /**
+     * The value of the tag.
+     *  Constraints: Tag values are case-sensitive and accept a maximum of 256 Unicode characters.
+     */
     Value: string;
 }

package/lib/types/cfn-resource-types/aws-ec2-vpnconcentrator.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLWVjMi12cG5jb25jZW50cmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJhd3MtZWMyLXZwbmNvbmNlbnRyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXNvdXJjZSBUeXBlIGRlZmluaXRpb24gZm9yIEFXUzo6RUMyOjpWUE5Db25jZW50cmF0b3JcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBfQVdTX0VDMl9WUE5DT05DRU5UUkFUT1Ige1xuLyoqXG4gKiBUaGUgcHJvdmlkZXItYXNzaWduZWQgdW5pcXVlIElEIGZvciB0aGlzIG1hbmFnZWQgcmVzb3VyY2VcbiAqL1xuVnBuQ29uY2VudHJhdG9ySWQ/OiBzdHJpbmdcbi8qKlxuICogVGhlIElEIG9mIHRoZSB0cmFuc2l0IGdhdGV3YXlcbiAqL1xuVHJhbnNpdEdhdGV3YXlJZDogc3RyaW5nXG4vKipcbiAqIFRoZSBJRCBvZiB0aGUgdHJhbnNpdCBnYXRld2F5IGF0dGFjaG1lbnRcbiAqL1xuVHJhbnNpdEdhdGV3YXlBdHRhY2htZW50SWQ/OiBzdHJpbmdcbi8qKlxuICogVGhlIHR5cGUgb2YgVlBOIGNvbmNlbnRyYXRvclxuICovXG5UeXBlOiBzdHJpbmdcbi8qKlxuICogQW55IHRhZ3MgYXNzaWduZWQgdG8gdGhlIFZQTiBjb25jZW50cmF0b3IuXG4gKi9cblRhZ3M/OiBUYWdbXVxufVxuZXhwb3J0IGludGVyZmFjZSBUYWcge1xuS2V5OiBzdHJpbmdcblZhbHVlOiBzdHJpbmdcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLWVjMi12cG5jb25jZW50cmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJhd3MtZWMyLXZwbmNvbmNlbnRyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBEZXNjcmliZXMgYSBWUE4gY29uY2VudHJhdG9yLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIF9BV1NfRUMyX1ZQTkNPTkNFTlRSQVRPUiB7XG5WcG5Db25jZW50cmF0b3JJZD86IHN0cmluZ1xuLyoqXG4gKiBUaGUgSUQgb2YgdGhlIHRyYW5zaXQgZ2F0ZXdheSBhc3NvY2lhdGVkIHdpdGggdGhlIFZQTiBjb25jZW50cmF0b3IuXG4gKi9cblRyYW5zaXRHYXRld2F5SWQ6IHN0cmluZ1xuVHJhbnNpdEdhdGV3YXlBdHRhY2htZW50SWQ/OiBzdHJpbmdcbi8qKlxuICogVGhlIHR5cGUgb2YgVlBOIGNvbmNlbnRyYXRvci5cbiAqL1xuVHlwZTogc3RyaW5nXG4vKipcbiAqIEFueSB0YWdzIGFzc2lnbmVkIHRvIHRoZSBWUE4gY29uY2VudHJhdG9yLlxuICovXG5UYWdzPzogVGFnW11cbn1cbi8qKlxuICogRGVzY3JpYmVzIGEgdGFnLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFRhZyB7XG4vKipcbiAqIFRoZSBrZXkgb2YgdGhlIHRhZy5cbiAqICBDb25zdHJhaW50czogVGFnIGtleXMgYXJlIGNhc2Utc2Vuc2l0aXZlIGFuZCBhY2NlcHQgYSBtYXhpbXVtIG9mIDEyNyBVbmljb2RlIGNoYXJhY3RlcnMuIE1heSBub3QgYmVnaW4gd2l0aCBgYGF3czpgYC5cbiAqL1xuS2V5OiBzdHJpbmdcbi8qKlxuICogVGhlIHZhbHVlIG9mIHRoZSB0YWcuXG4gKiAgQ29uc3RyYWludHM6IFRhZyB2YWx1ZXMgYXJlIGNhc2Utc2Vuc2l0aXZlIGFuZCBhY2NlcHQgYSBtYXhpbXVtIG9mIDI1NiBVbmljb2RlIGNoYXJhY3RlcnMuXG4gKi9cblZhbHVlOiBzdHJpbmdcbn1cbiJdfQ==