@aws-sdk/client-ec2 3.662.0 → 3.665.0

package/dist-types/commands/CreateNetworkAclEntryCommand.d.ts

@@ -43,22 +43,22 @@ declare const CreateNetworkAclEntryCommand_base: {
  * // const { EC2Client, CreateNetworkAclEntryCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateNetworkAclEntryRequest
- *   CidrBlock: "STRING_VALUE",
  *   DryRun: true || false,
+ *   NetworkAclId: "STRING_VALUE", // required
+ *   RuleNumber: Number("int"), // required
+ *   Protocol: "STRING_VALUE", // required
+ *   RuleAction: "allow" || "deny", // required
  *   Egress: true || false, // required
+ *   CidrBlock: "STRING_VALUE",
+ *   Ipv6CidrBlock: "STRING_VALUE",
  *   IcmpTypeCode: { // IcmpTypeCode
  *     Code: Number("int"),
  *     Type: Number("int"),
  *   },
- *   Ipv6CidrBlock: "STRING_VALUE",
- *   NetworkAclId: "STRING_VALUE", // required
  *   PortRange: { // PortRange
  *     From: Number("int"),
  *     To: Number("int"),
  *   },
- *   Protocol: "STRING_VALUE", // required
- *   RuleAction: "allow" || "deny", // required
- *   RuleNumber: Number("int"), // required
  * };
  * const command = new CreateNetworkAclEntryCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/CreateNetworkInterfaceCommand.d.ts

@@ -39,26 +39,6 @@ declare const CreateNetworkInterfaceCommand_base: {
  * // const { EC2Client, CreateNetworkInterfaceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateNetworkInterfaceRequest
- *   Description: "STRING_VALUE",
- *   DryRun: true || false,
- *   Groups: [ // SecurityGroupIdStringList
- *     "STRING_VALUE",
- *   ],
- *   Ipv6AddressCount: Number("int"),
- *   Ipv6Addresses: [ // InstanceIpv6AddressList
- *     { // InstanceIpv6Address
- *       Ipv6Address: "STRING_VALUE",
- *       IsPrimaryIpv6: true || false,
- *     },
- *   ],
- *   PrivateIpAddress: "STRING_VALUE",
- *   PrivateIpAddresses: [ // PrivateIpAddressSpecificationList
- *     { // PrivateIpAddressSpecification
- *       Primary: true || false,
- *       PrivateIpAddress: "STRING_VALUE",
- *     },
- *   ],
- *   SecondaryPrivateIpAddressCount: Number("int"),
  *   Ipv4Prefixes: [ // Ipv4PrefixList
  *     { // Ipv4PrefixSpecificationRequest
  *       Ipv4Prefix: "STRING_VALUE",
@@ -72,7 +52,6 @@ declare const CreateNetworkInterfaceCommand_base: {
  *   ],
  *   Ipv6PrefixCount: Number("int"),
  *   InterfaceType: "efa" || "branch" || "trunk",
- *   SubnetId: "STRING_VALUE", // required
  *   TagSpecifications: [ // TagSpecificationList
  *     { // TagSpecification
  *       ResourceType: "capacity-reservation" || "client-vpn-endpoint" || "customer-gateway" || "carrier-gateway" || "coip-pool" || "dedicated-host" || "dhcp-options" || "egress-only-internet-gateway" || "elastic-ip" || "elastic-gpu" || "export-image-task" || "export-instance-task" || "fleet" || "fpga-image" || "host-reservation" || "image" || "import-image-task" || "import-snapshot-task" || "instance" || "instance-event-window" || "internet-gateway" || "ipam" || "ipam-pool" || "ipam-scope" || "ipv4pool-ec2" || "ipv6pool-ec2" || "key-pair" || "launch-template" || "local-gateway" || "local-gateway-route-table" || "local-gateway-virtual-interface" || "local-gateway-virtual-interface-group" || "local-gateway-route-table-vpc-association" || "local-gateway-route-table-virtual-interface-group-association" || "natgateway" || "network-acl" || "network-interface" || "network-insights-analysis" || "network-insights-path" || "network-insights-access-scope" || "network-insights-access-scope-analysis" || "placement-group" || "prefix-list" || "replace-root-volume-task" || "reserved-instances" || "route-table" || "security-group" || "security-group-rule" || "snapshot" || "spot-fleet-request" || "spot-instances-request" || "subnet" || "subnet-cidr-reservation" || "traffic-mirror-filter" || "traffic-mirror-session" || "traffic-mirror-target" || "transit-gateway" || "transit-gateway-attachment" || "transit-gateway-connect-peer" || "transit-gateway-multicast-domain" || "transit-gateway-policy-table" || "transit-gateway-route-table" || "transit-gateway-route-table-announcement" || "volume" || "vpc" || "vpc-endpoint" || "vpc-endpoint-connection" || "vpc-endpoint-service" || "vpc-endpoint-service-permission" || "vpc-peering-connection" || "vpn-connection" || "vpn-gateway" || "vpc-flow-log" || "capacity-reservation-fleet" || "traffic-mirror-filter-rule" || "vpc-endpoint-connection-device-type" || "verified-access-instance" || "verified-access-group" || "verified-access-endpoint" || "verified-access-policy" || "verified-access-trust-provider" || "vpn-connection-device-type" || "vpc-block-public-access-exclusion" || "ipam-resource-discovery" || "ipam-resource-discovery-association" || "instance-connect-endpoint" || "ipam-external-resource-verification-token",
@@ -91,6 +70,27 @@ declare const CreateNetworkInterfaceCommand_base: {
  *     UdpStreamTimeout: Number("int"),
  *     UdpTimeout: Number("int"),
  *   },
+ *   SubnetId: "STRING_VALUE", // required
+ *   Description: "STRING_VALUE",
+ *   PrivateIpAddress: "STRING_VALUE",
+ *   Groups: [ // SecurityGroupIdStringList
+ *     "STRING_VALUE",
+ *   ],
+ *   PrivateIpAddresses: [ // PrivateIpAddressSpecificationList
+ *     { // PrivateIpAddressSpecification
+ *       Primary: true || false,
+ *       PrivateIpAddress: "STRING_VALUE",
+ *     },
+ *   ],
+ *   SecondaryPrivateIpAddressCount: Number("int"),
+ *   Ipv6Addresses: [ // InstanceIpv6AddressList
+ *     { // InstanceIpv6Address
+ *       Ipv6Address: "STRING_VALUE",
+ *       IsPrimaryIpv6: true || false,
+ *     },
+ *   ],
+ *   Ipv6AddressCount: Number("int"),
+ *   DryRun: true || false,
  * };
  * const command = new CreateNetworkInterfaceCommand(input);
  * const response = await client.send(command);
@@ -130,8 +130,8 @@ declare const CreateNetworkInterfaceCommand_base: {
  * //     Description: "STRING_VALUE",
  * //     Groups: [ // GroupIdentifierList
  * //       { // GroupIdentifier
- * //         GroupName: "STRING_VALUE",
  * //         GroupId: "STRING_VALUE",
+ * //         GroupName: "STRING_VALUE",
  * //       },
  * //     ],
  * //     InterfaceType: "interface" || "natGateway" || "efa" || "trunk" || "load_balancer" || "network_load_balancer" || "vpc_endpoint" || "branch" || "transit_gateway" || "lambda" || "quicksight" || "global_accelerator_managed" || "api_gateway_managed" || "gateway_load_balancer" || "gateway_load_balancer_endpoint" || "iot_rules_managed" || "aws_codestar_connections_managed",

package/dist-types/commands/CreatePlacementGroupCommand.d.ts

@@ -44,9 +44,6 @@ declare const CreatePlacementGroupCommand_base: {
  * // const { EC2Client, CreatePlacementGroupCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreatePlacementGroupRequest
- *   DryRun: true || false,
- *   GroupName: "STRING_VALUE",
- *   Strategy: "cluster" || "spread" || "partition",
  *   PartitionCount: Number("int"),
  *   TagSpecifications: [ // TagSpecificationList
  *     { // TagSpecification
@@ -60,6 +57,9 @@ declare const CreatePlacementGroupCommand_base: {
  *     },
  *   ],
  *   SpreadLevel: "host" || "rack",
+ *   DryRun: true || false,
+ *   GroupName: "STRING_VALUE",
+ *   Strategy: "cluster" || "spread" || "partition",
  * };
  * const command = new CreatePlacementGroupCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/CreateReservedInstancesListingCommand.d.ts

@@ -50,16 +50,16 @@ declare const CreateReservedInstancesListingCommand_base: {
  * // const { EC2Client, CreateReservedInstancesListingCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateReservedInstancesListingRequest
- *   ClientToken: "STRING_VALUE", // required
+ *   ReservedInstancesId: "STRING_VALUE", // required
  *   InstanceCount: Number("int"), // required
  *   PriceSchedules: [ // PriceScheduleSpecificationList // required
  *     { // PriceScheduleSpecification
- *       CurrencyCode: "USD",
- *       Price: Number("double"),
  *       Term: Number("long"),
+ *       Price: Number("double"),
+ *       CurrencyCode: "USD",
  *     },
  *   ],
- *   ReservedInstancesId: "STRING_VALUE", // required
+ *   ClientToken: "STRING_VALUE", // required
  * };
  * const command = new CreateReservedInstancesListingCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/CreateRouteCommand.d.ts

@@ -55,22 +55,22 @@ declare const CreateRouteCommand_base: {
  * // const { EC2Client, CreateRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateRouteRequest
- *   DestinationCidrBlock: "STRING_VALUE",
- *   DestinationIpv6CidrBlock: "STRING_VALUE",
  *   DestinationPrefixListId: "STRING_VALUE",
- *   DryRun: true || false,
  *   VpcEndpointId: "STRING_VALUE",
- *   EgressOnlyInternetGatewayId: "STRING_VALUE",
- *   GatewayId: "STRING_VALUE",
- *   InstanceId: "STRING_VALUE",
- *   NatGatewayId: "STRING_VALUE",
  *   TransitGatewayId: "STRING_VALUE",
  *   LocalGatewayId: "STRING_VALUE",
  *   CarrierGatewayId: "STRING_VALUE",
- *   NetworkInterfaceId: "STRING_VALUE",
+ *   CoreNetworkArn: "STRING_VALUE",
+ *   DryRun: true || false,
  *   RouteTableId: "STRING_VALUE", // required
+ *   DestinationCidrBlock: "STRING_VALUE",
+ *   GatewayId: "STRING_VALUE",
+ *   DestinationIpv6CidrBlock: "STRING_VALUE",
+ *   EgressOnlyInternetGatewayId: "STRING_VALUE",
+ *   InstanceId: "STRING_VALUE",
+ *   NetworkInterfaceId: "STRING_VALUE",
  *   VpcPeeringConnectionId: "STRING_VALUE",
- *   CoreNetworkArn: "STRING_VALUE",
+ *   NatGatewayId: "STRING_VALUE",
  * };
  * const command = new CreateRouteCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/CreateRouteTableCommand.d.ts

@@ -37,8 +37,6 @@ declare const CreateRouteTableCommand_base: {
  * // const { EC2Client, CreateRouteTableCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateRouteTableRequest
- *   DryRun: true || false,
- *   VpcId: "STRING_VALUE", // required
  *   TagSpecifications: [ // TagSpecificationList
  *     { // TagSpecification
  *       ResourceType: "capacity-reservation" || "client-vpn-endpoint" || "customer-gateway" || "carrier-gateway" || "coip-pool" || "dedicated-host" || "dhcp-options" || "egress-only-internet-gateway" || "elastic-ip" || "elastic-gpu" || "export-image-task" || "export-instance-task" || "fleet" || "fpga-image" || "host-reservation" || "image" || "import-image-task" || "import-snapshot-task" || "instance" || "instance-event-window" || "internet-gateway" || "ipam" || "ipam-pool" || "ipam-scope" || "ipv4pool-ec2" || "ipv6pool-ec2" || "key-pair" || "launch-template" || "local-gateway" || "local-gateway-route-table" || "local-gateway-virtual-interface" || "local-gateway-virtual-interface-group" || "local-gateway-route-table-vpc-association" || "local-gateway-route-table-virtual-interface-group-association" || "natgateway" || "network-acl" || "network-interface" || "network-insights-analysis" || "network-insights-path" || "network-insights-access-scope" || "network-insights-access-scope-analysis" || "placement-group" || "prefix-list" || "replace-root-volume-task" || "reserved-instances" || "route-table" || "security-group" || "security-group-rule" || "snapshot" || "spot-fleet-request" || "spot-instances-request" || "subnet" || "subnet-cidr-reservation" || "traffic-mirror-filter" || "traffic-mirror-session" || "traffic-mirror-target" || "transit-gateway" || "transit-gateway-attachment" || "transit-gateway-connect-peer" || "transit-gateway-multicast-domain" || "transit-gateway-policy-table" || "transit-gateway-route-table" || "transit-gateway-route-table-announcement" || "volume" || "vpc" || "vpc-endpoint" || "vpc-endpoint-connection" || "vpc-endpoint-service" || "vpc-endpoint-service-permission" || "vpc-peering-connection" || "vpn-connection" || "vpn-gateway" || "vpc-flow-log" || "capacity-reservation-fleet" || "traffic-mirror-filter-rule" || "vpc-endpoint-connection-device-type" || "verified-access-instance" || "verified-access-group" || "verified-access-endpoint" || "verified-access-policy" || "verified-access-trust-provider" || "vpn-connection-device-type" || "vpc-block-public-access-exclusion" || "ipam-resource-discovery" || "ipam-resource-discovery-association" || "instance-connect-endpoint" || "ipam-external-resource-verification-token",
@@ -51,6 +49,8 @@ declare const CreateRouteTableCommand_base: {
  *     },
  *   ],
  *   ClientToken: "STRING_VALUE",
+ *   DryRun: true || false,
+ *   VpcId: "STRING_VALUE", // required
  * };
  * const command = new CreateRouteTableCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/CreateSnapshotCommand.d.ts

@@ -78,18 +78,6 @@ declare const CreateSnapshotCommand_base: {
  * const command = new CreateSnapshotCommand(input);
  * const response = await client.send(command);
  * // { // Snapshot
- * //   DataEncryptionKeyId: "STRING_VALUE",
- * //   Description: "STRING_VALUE",
- * //   Encrypted: true || false,
- * //   KmsKeyId: "STRING_VALUE",
- * //   OwnerId: "STRING_VALUE",
- * //   Progress: "STRING_VALUE",
- * //   SnapshotId: "STRING_VALUE",
- * //   StartTime: new Date("TIMESTAMP"),
- * //   State: "pending" || "completed" || "error" || "recoverable" || "recovering",
- * //   StateMessage: "STRING_VALUE",
- * //   VolumeId: "STRING_VALUE",
- * //   VolumeSize: Number("int"),
  * //   OwnerAlias: "STRING_VALUE",
  * //   OutpostArn: "STRING_VALUE",
  * //   Tags: [ // TagList
@@ -101,6 +89,18 @@ declare const CreateSnapshotCommand_base: {
  * //   StorageTier: "archive" || "standard",
  * //   RestoreExpiryTime: new Date("TIMESTAMP"),
  * //   SseType: "sse-ebs" || "sse-kms" || "none",
+ * //   SnapshotId: "STRING_VALUE",
+ * //   VolumeId: "STRING_VALUE",
+ * //   State: "pending" || "completed" || "error" || "recoverable" || "recovering",
+ * //   StateMessage: "STRING_VALUE",
+ * //   StartTime: new Date("TIMESTAMP"),
+ * //   Progress: "STRING_VALUE",
+ * //   OwnerId: "STRING_VALUE",
+ * //   Description: "STRING_VALUE",
+ * //   VolumeSize: Number("int"),
+ * //   Encrypted: true || false,
+ * //   KmsKeyId: "STRING_VALUE",
+ * //   DataEncryptionKeyId: "STRING_VALUE",
  * // };
  *
  * ```

package/dist-types/commands/CreateSpotDatafeedSubscriptionCommand.d.ts

@@ -38,8 +38,8 @@ declare const CreateSpotDatafeedSubscriptionCommand_base: {
  * // const { EC2Client, CreateSpotDatafeedSubscriptionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateSpotDatafeedSubscriptionRequest
- *   Bucket: "STRING_VALUE", // required
  *   DryRun: true || false,
+ *   Bucket: "STRING_VALUE", // required
  *   Prefix: "STRING_VALUE",
  * };
  * const command = new CreateSpotDatafeedSubscriptionCommand(input);

package/dist-types/commands/CreateSubnetCidrReservationCommand.d.ts

@@ -28,8 +28,8 @@ declare const CreateSubnetCidrReservationCommand_base: {
 };
 /**
  * <p>Creates a subnet CIDR reservation. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html">Subnet CIDR reservations</a>
- *             in the <i>Amazon VPC User Guide</i> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">Assign prefixes
- *                 to network interfaces</a> in the <i>Amazon EC2 User Guide</i>.</p>
+ *             in the <i>Amazon VPC User Guide</i> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-prefixes.html">Manage prefixes
+ *                 for your network interfaces</a> in the <i>Amazon EC2 User Guide</i>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/CreateSubnetCommand.d.ts

@@ -68,29 +68,21 @@ declare const CreateSubnetCommand_base: {
  *   Ipv6CidrBlock: "STRING_VALUE",
  *   OutpostArn: "STRING_VALUE",
  *   VpcId: "STRING_VALUE", // required
- *   DryRun: true || false,
  *   Ipv6Native: true || false,
  *   Ipv4IpamPoolId: "STRING_VALUE",
  *   Ipv4NetmaskLength: Number("int"),
  *   Ipv6IpamPoolId: "STRING_VALUE",
  *   Ipv6NetmaskLength: Number("int"),
+ *   DryRun: true || false,
  * };
  * const command = new CreateSubnetCommand(input);
  * const response = await client.send(command);
  * // { // CreateSubnetResult
  * //   Subnet: { // Subnet
- * //     AvailabilityZone: "STRING_VALUE",
  * //     AvailabilityZoneId: "STRING_VALUE",
- * //     AvailableIpAddressCount: Number("int"),
- * //     CidrBlock: "STRING_VALUE",
- * //     DefaultForAz: true || false,
  * //     EnableLniAtDeviceIndex: Number("int"),
- * //     MapPublicIpOnLaunch: true || false,
  * //     MapCustomerOwnedIpOnLaunch: true || false,
  * //     CustomerOwnedIpv4Pool: "STRING_VALUE",
- * //     State: "pending" || "available" || "unavailable",
- * //     SubnetId: "STRING_VALUE",
- * //     VpcId: "STRING_VALUE",
  * //     OwnerId: "STRING_VALUE",
  * //     AssignIpv6AddressOnCreation: true || false,
  * //     Ipv6CidrBlockAssociationSet: [ // SubnetIpv6CidrBlockAssociationSet
@@ -120,6 +112,14 @@ declare const CreateSubnetCommand_base: {
  * //       EnableResourceNameDnsARecord: true || false,
  * //       EnableResourceNameDnsAAAARecord: true || false,
  * //     },
+ * //     SubnetId: "STRING_VALUE",
+ * //     State: "pending" || "available" || "unavailable",
+ * //     VpcId: "STRING_VALUE",
+ * //     CidrBlock: "STRING_VALUE",
+ * //     AvailableIpAddressCount: Number("int"),
+ * //     AvailabilityZone: "STRING_VALUE",
+ * //     DefaultForAz: true || false,
+ * //     MapPublicIpOnLaunch: true || false,
  * //   },
  * // };
  *

package/dist-types/commands/CreateVolumeCommand.d.ts

@@ -53,7 +53,6 @@ declare const CreateVolumeCommand_base: {
  *   Size: Number("int"),
  *   SnapshotId: "STRING_VALUE",
  *   VolumeType: "standard" || "io1" || "io2" || "gp2" || "sc1" || "st1" || "gp3",
- *   DryRun: true || false,
  *   TagSpecifications: [ // TagSpecificationList
  *     { // TagSpecification
  *       ResourceType: "capacity-reservation" || "client-vpn-endpoint" || "customer-gateway" || "carrier-gateway" || "coip-pool" || "dedicated-host" || "dhcp-options" || "egress-only-internet-gateway" || "elastic-ip" || "elastic-gpu" || "export-image-task" || "export-instance-task" || "fleet" || "fpga-image" || "host-reservation" || "image" || "import-image-task" || "import-snapshot-task" || "instance" || "instance-event-window" || "internet-gateway" || "ipam" || "ipam-pool" || "ipam-scope" || "ipv4pool-ec2" || "ipv6pool-ec2" || "key-pair" || "launch-template" || "local-gateway" || "local-gateway-route-table" || "local-gateway-virtual-interface" || "local-gateway-virtual-interface-group" || "local-gateway-route-table-vpc-association" || "local-gateway-route-table-virtual-interface-group-association" || "natgateway" || "network-acl" || "network-interface" || "network-insights-analysis" || "network-insights-path" || "network-insights-access-scope" || "network-insights-access-scope-analysis" || "placement-group" || "prefix-list" || "replace-root-volume-task" || "reserved-instances" || "route-table" || "security-group" || "security-group-rule" || "snapshot" || "spot-fleet-request" || "spot-instances-request" || "subnet" || "subnet-cidr-reservation" || "traffic-mirror-filter" || "traffic-mirror-session" || "traffic-mirror-target" || "transit-gateway" || "transit-gateway-attachment" || "transit-gateway-connect-peer" || "transit-gateway-multicast-domain" || "transit-gateway-policy-table" || "transit-gateway-route-table" || "transit-gateway-route-table-announcement" || "volume" || "vpc" || "vpc-endpoint" || "vpc-endpoint-connection" || "vpc-endpoint-service" || "vpc-endpoint-service-permission" || "vpc-peering-connection" || "vpn-connection" || "vpn-gateway" || "vpc-flow-log" || "capacity-reservation-fleet" || "traffic-mirror-filter-rule" || "vpc-endpoint-connection-device-type" || "verified-access-instance" || "verified-access-group" || "verified-access-endpoint" || "verified-access-policy" || "verified-access-trust-provider" || "vpn-connection-device-type" || "vpc-block-public-access-exclusion" || "ipam-resource-discovery" || "ipam-resource-discovery-association" || "instance-connect-endpoint" || "ipam-external-resource-verification-token",
@@ -68,31 +67,12 @@ declare const CreateVolumeCommand_base: {
  *   MultiAttachEnabled: true || false,
  *   Throughput: Number("int"),
  *   ClientToken: "STRING_VALUE",
+ *   DryRun: true || false,
  * };
  * const command = new CreateVolumeCommand(input);
  * const response = await client.send(command);
  * // { // Volume
- * //   Attachments: [ // VolumeAttachmentList
- * //     { // VolumeAttachment
- * //       AttachTime: new Date("TIMESTAMP"),
- * //       Device: "STRING_VALUE",
- * //       InstanceId: "STRING_VALUE",
- * //       State: "attaching" || "attached" || "detaching" || "detached" || "busy",
- * //       VolumeId: "STRING_VALUE",
- * //       DeleteOnTermination: true || false,
- * //       AssociatedResource: "STRING_VALUE",
- * //       InstanceOwningService: "STRING_VALUE",
- * //     },
- * //   ],
- * //   AvailabilityZone: "STRING_VALUE",
- * //   CreateTime: new Date("TIMESTAMP"),
- * //   Encrypted: true || false,
- * //   KmsKeyId: "STRING_VALUE",
  * //   OutpostArn: "STRING_VALUE",
- * //   Size: Number("int"),
- * //   SnapshotId: "STRING_VALUE",
- * //   State: "creating" || "available" || "in-use" || "deleting" || "deleted" || "error",
- * //   VolumeId: "STRING_VALUE",
  * //   Iops: Number("int"),
  * //   Tags: [ // TagList
  * //     { // Tag
@@ -105,6 +85,26 @@ declare const CreateVolumeCommand_base: {
  * //   MultiAttachEnabled: true || false,
  * //   Throughput: Number("int"),
  * //   SseType: "sse-ebs" || "sse-kms" || "none",
+ * //   VolumeId: "STRING_VALUE",
+ * //   Size: Number("int"),
+ * //   SnapshotId: "STRING_VALUE",
+ * //   AvailabilityZone: "STRING_VALUE",
+ * //   State: "creating" || "available" || "in-use" || "deleting" || "deleted" || "error",
+ * //   CreateTime: new Date("TIMESTAMP"),
+ * //   Attachments: [ // VolumeAttachmentList
+ * //     { // VolumeAttachment
+ * //       DeleteOnTermination: true || false,
+ * //       AssociatedResource: "STRING_VALUE",
+ * //       InstanceOwningService: "STRING_VALUE",
+ * //       VolumeId: "STRING_VALUE",
+ * //       InstanceId: "STRING_VALUE",
+ * //       Device: "STRING_VALUE",
+ * //       State: "attaching" || "attached" || "detaching" || "detached" || "busy",
+ * //       AttachTime: new Date("TIMESTAMP"),
+ * //     },
+ * //   ],
+ * //   Encrypted: true || false,
+ * //   KmsKeyId: "STRING_VALUE",
  * // };
  *
  * ```

package/dist-types/commands/CreateVpcCommand.d.ts

@@ -32,7 +32,7 @@ declare const CreateVpcCommand_base: {
  *          <p>You can optionally request an IPv6 CIDR block for the VPC. You can request an
  *             Amazon-provided IPv6 CIDR block from Amazon's pool of IPv6 addresses or an IPv6 CIDR
  *             block from an IPv6 address pool that you provisioned through bring your own IP addresses
- *                 (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>).</p>
+ *             (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>).</p>
  *          <p>By default, each instance that you launch in the VPC has the default DHCP options, which
  * 			include only a default DNS server that we provide (AmazonProvidedDNS). For more
  * 			information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP option sets</a> in the <i>Amazon VPC User Guide</i>.</p>
@@ -47,15 +47,12 @@ declare const CreateVpcCommand_base: {
  * const client = new EC2Client(config);
  * const input = { // CreateVpcRequest
  *   CidrBlock: "STRING_VALUE",
- *   AmazonProvidedIpv6CidrBlock: true || false,
  *   Ipv6Pool: "STRING_VALUE",
  *   Ipv6CidrBlock: "STRING_VALUE",
  *   Ipv4IpamPoolId: "STRING_VALUE",
  *   Ipv4NetmaskLength: Number("int"),
  *   Ipv6IpamPoolId: "STRING_VALUE",
  *   Ipv6NetmaskLength: Number("int"),
- *   DryRun: true || false,
- *   InstanceTenancy: "default" || "dedicated" || "host",
  *   Ipv6CidrBlockNetworkBorderGroup: "STRING_VALUE",
  *   TagSpecifications: [ // TagSpecificationList
  *     { // TagSpecification
@@ -68,15 +65,14 @@ declare const CreateVpcCommand_base: {
  *       ],
  *     },
  *   ],
+ *   DryRun: true || false,
+ *   InstanceTenancy: "default" || "dedicated" || "host",
+ *   AmazonProvidedIpv6CidrBlock: true || false,
  * };
  * const command = new CreateVpcCommand(input);
  * const response = await client.send(command);
  * // { // CreateVpcResult
  * //   Vpc: { // Vpc
- * //     CidrBlock: "STRING_VALUE",
- * //     DhcpOptionsId: "STRING_VALUE",
- * //     State: "pending" || "available",
- * //     VpcId: "STRING_VALUE",
  * //     OwnerId: "STRING_VALUE",
  * //     InstanceTenancy: "default" || "dedicated" || "host",
  * //     Ipv6CidrBlockAssociationSet: [ // VpcIpv6CidrBlockAssociationSet
@@ -110,6 +106,10 @@ declare const CreateVpcCommand_base: {
  * //         Value: "STRING_VALUE",
  * //       },
  * //     ],
+ * //     VpcId: "STRING_VALUE",
+ * //     State: "pending" || "available",
+ * //     CidrBlock: "STRING_VALUE",
+ * //     DhcpOptionsId: "STRING_VALUE",
  * //   },
  * // };
  *

package/dist-types/commands/CreateVpcPeeringConnectionCommand.d.ts

@@ -47,10 +47,6 @@ declare const CreateVpcPeeringConnectionCommand_base: {
  * // const { EC2Client, CreateVpcPeeringConnectionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateVpcPeeringConnectionRequest
- *   DryRun: true || false,
- *   PeerOwnerId: "STRING_VALUE",
- *   PeerVpcId: "STRING_VALUE",
- *   VpcId: "STRING_VALUE", // required
  *   PeerRegion: "STRING_VALUE",
  *   TagSpecifications: [ // TagSpecificationList
  *     { // TagSpecification
@@ -63,6 +59,10 @@ declare const CreateVpcPeeringConnectionCommand_base: {
  *       ],
  *     },
  *   ],
+ *   DryRun: true || false,
+ *   VpcId: "STRING_VALUE", // required
+ *   PeerVpcId: "STRING_VALUE",
+ *   PeerOwnerId: "STRING_VALUE",
  * };
  * const command = new CreateVpcPeeringConnectionCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/CreateVpnConnectionCommand.d.ts

@@ -55,10 +55,20 @@ declare const CreateVpnConnectionCommand_base: {
  *   Type: "STRING_VALUE", // required
  *   VpnGatewayId: "STRING_VALUE",
  *   TransitGatewayId: "STRING_VALUE",
+ *   TagSpecifications: [ // TagSpecificationList
+ *     { // TagSpecification
+ *       ResourceType: "capacity-reservation" || "client-vpn-endpoint" || "customer-gateway" || "carrier-gateway" || "coip-pool" || "dedicated-host" || "dhcp-options" || "egress-only-internet-gateway" || "elastic-ip" || "elastic-gpu" || "export-image-task" || "export-instance-task" || "fleet" || "fpga-image" || "host-reservation" || "image" || "import-image-task" || "import-snapshot-task" || "instance" || "instance-event-window" || "internet-gateway" || "ipam" || "ipam-pool" || "ipam-scope" || "ipv4pool-ec2" || "ipv6pool-ec2" || "key-pair" || "launch-template" || "local-gateway" || "local-gateway-route-table" || "local-gateway-virtual-interface" || "local-gateway-virtual-interface-group" || "local-gateway-route-table-vpc-association" || "local-gateway-route-table-virtual-interface-group-association" || "natgateway" || "network-acl" || "network-interface" || "network-insights-analysis" || "network-insights-path" || "network-insights-access-scope" || "network-insights-access-scope-analysis" || "placement-group" || "prefix-list" || "replace-root-volume-task" || "reserved-instances" || "route-table" || "security-group" || "security-group-rule" || "snapshot" || "spot-fleet-request" || "spot-instances-request" || "subnet" || "subnet-cidr-reservation" || "traffic-mirror-filter" || "traffic-mirror-session" || "traffic-mirror-target" || "transit-gateway" || "transit-gateway-attachment" || "transit-gateway-connect-peer" || "transit-gateway-multicast-domain" || "transit-gateway-policy-table" || "transit-gateway-route-table" || "transit-gateway-route-table-announcement" || "volume" || "vpc" || "vpc-endpoint" || "vpc-endpoint-connection" || "vpc-endpoint-service" || "vpc-endpoint-service-permission" || "vpc-peering-connection" || "vpn-connection" || "vpn-gateway" || "vpc-flow-log" || "capacity-reservation-fleet" || "traffic-mirror-filter-rule" || "vpc-endpoint-connection-device-type" || "verified-access-instance" || "verified-access-group" || "verified-access-endpoint" || "verified-access-policy" || "verified-access-trust-provider" || "vpn-connection-device-type" || "vpc-block-public-access-exclusion" || "ipam-resource-discovery" || "ipam-resource-discovery-association" || "instance-connect-endpoint" || "ipam-external-resource-verification-token",
+ *       Tags: [ // TagList
+ *         { // Tag
+ *           Key: "STRING_VALUE",
+ *           Value: "STRING_VALUE",
+ *         },
+ *       ],
+ *     },
+ *   ],
  *   DryRun: true || false,
  *   Options: { // VpnConnectionOptionsSpecification
  *     EnableAcceleration: true || false,
- *     StaticRoutesOnly: true || false,
  *     TunnelInsideIpVersion: "ipv4" || "ipv6",
  *     TunnelOptions: [ // VpnTunnelOptionsSpecificationsList
  *       { // VpnTunnelOptionsSpecification
@@ -124,30 +134,14 @@ declare const CreateVpnConnectionCommand_base: {
  *     RemoteIpv6NetworkCidr: "STRING_VALUE",
  *     OutsideIpAddressType: "STRING_VALUE",
  *     TransportTransitGatewayAttachmentId: "STRING_VALUE",
+ *     StaticRoutesOnly: true || false,
  *   },
- *   TagSpecifications: [ // TagSpecificationList
- *     { // TagSpecification
- *       ResourceType: "capacity-reservation" || "client-vpn-endpoint" || "customer-gateway" || "carrier-gateway" || "coip-pool" || "dedicated-host" || "dhcp-options" || "egress-only-internet-gateway" || "elastic-ip" || "elastic-gpu" || "export-image-task" || "export-instance-task" || "fleet" || "fpga-image" || "host-reservation" || "image" || "import-image-task" || "import-snapshot-task" || "instance" || "instance-event-window" || "internet-gateway" || "ipam" || "ipam-pool" || "ipam-scope" || "ipv4pool-ec2" || "ipv6pool-ec2" || "key-pair" || "launch-template" || "local-gateway" || "local-gateway-route-table" || "local-gateway-virtual-interface" || "local-gateway-virtual-interface-group" || "local-gateway-route-table-vpc-association" || "local-gateway-route-table-virtual-interface-group-association" || "natgateway" || "network-acl" || "network-interface" || "network-insights-analysis" || "network-insights-path" || "network-insights-access-scope" || "network-insights-access-scope-analysis" || "placement-group" || "prefix-list" || "replace-root-volume-task" || "reserved-instances" || "route-table" || "security-group" || "security-group-rule" || "snapshot" || "spot-fleet-request" || "spot-instances-request" || "subnet" || "subnet-cidr-reservation" || "traffic-mirror-filter" || "traffic-mirror-session" || "traffic-mirror-target" || "transit-gateway" || "transit-gateway-attachment" || "transit-gateway-connect-peer" || "transit-gateway-multicast-domain" || "transit-gateway-policy-table" || "transit-gateway-route-table" || "transit-gateway-route-table-announcement" || "volume" || "vpc" || "vpc-endpoint" || "vpc-endpoint-connection" || "vpc-endpoint-service" || "vpc-endpoint-service-permission" || "vpc-peering-connection" || "vpn-connection" || "vpn-gateway" || "vpc-flow-log" || "capacity-reservation-fleet" || "traffic-mirror-filter-rule" || "vpc-endpoint-connection-device-type" || "verified-access-instance" || "verified-access-group" || "verified-access-endpoint" || "verified-access-policy" || "verified-access-trust-provider" || "vpn-connection-device-type" || "vpc-block-public-access-exclusion" || "ipam-resource-discovery" || "ipam-resource-discovery-association" || "instance-connect-endpoint" || "ipam-external-resource-verification-token",
- *       Tags: [ // TagList
- *         { // Tag
- *           Key: "STRING_VALUE",
- *           Value: "STRING_VALUE",
- *         },
- *       ],
- *     },
- *   ],
  * };
  * const command = new CreateVpnConnectionCommand(input);
  * const response = await client.send(command);
  * // { // CreateVpnConnectionResult
  * //   VpnConnection: { // VpnConnection
- * //     CustomerGatewayConfiguration: "STRING_VALUE",
- * //     CustomerGatewayId: "STRING_VALUE",
  * //     Category: "STRING_VALUE",
- * //     State: "pending" || "available" || "deleting" || "deleted",
- * //     Type: "ipsec.1",
- * //     VpnConnectionId: "STRING_VALUE",
- * //     VpnGatewayId: "STRING_VALUE",
  * //     TransitGatewayId: "STRING_VALUE",
  * //     CoreNetworkArn: "STRING_VALUE",
  * //     CoreNetworkAttachmentArn: "STRING_VALUE",
@@ -245,6 +239,12 @@ declare const CreateVpnConnectionCommand_base: {
  * //         CertificateArn: "STRING_VALUE",
  * //       },
  * //     ],
+ * //     VpnConnectionId: "STRING_VALUE",
+ * //     State: "pending" || "available" || "deleting" || "deleted",
+ * //     CustomerGatewayConfiguration: "STRING_VALUE",
+ * //     Type: "ipsec.1",
+ * //     CustomerGatewayId: "STRING_VALUE",
+ * //     VpnGatewayId: "STRING_VALUE",
  * //   },
  * // };
  *

package/dist-types/commands/CreateVpnGatewayCommand.d.ts

@@ -59,16 +59,6 @@ declare const CreateVpnGatewayCommand_base: {
  * const response = await client.send(command);
  * // { // CreateVpnGatewayResult
  * //   VpnGateway: { // VpnGateway
- * //     AvailabilityZone: "STRING_VALUE",
- * //     State: "pending" || "available" || "deleting" || "deleted",
- * //     Type: "ipsec.1",
- * //     VpcAttachments: [ // VpcAttachmentList
- * //       { // VpcAttachment
- * //         State: "attaching" || "attached" || "detaching" || "detached",
- * //         VpcId: "STRING_VALUE",
- * //       },
- * //     ],
- * //     VpnGatewayId: "STRING_VALUE",
  * //     AmazonSideAsn: Number("long"),
  * //     Tags: [ // TagList
  * //       { // Tag
@@ -76,6 +66,16 @@ declare const CreateVpnGatewayCommand_base: {
  * //         Value: "STRING_VALUE",
  * //       },
  * //     ],
+ * //     VpnGatewayId: "STRING_VALUE",
+ * //     State: "pending" || "available" || "deleting" || "deleted",
+ * //     Type: "ipsec.1",
+ * //     AvailabilityZone: "STRING_VALUE",
+ * //     VpcAttachments: [ // VpcAttachmentList
+ * //       { // VpcAttachment
+ * //         VpcId: "STRING_VALUE",
+ * //         State: "attaching" || "attached" || "detaching" || "detached",
+ * //       },
+ * //     ],
  * //   },
  * // };
  *

package/dist-types/commands/DeleteNetworkAclEntryCommand.d.ts

@@ -36,9 +36,9 @@ declare const DeleteNetworkAclEntryCommand_base: {
  * const client = new EC2Client(config);
  * const input = { // DeleteNetworkAclEntryRequest
  *   DryRun: true || false,
- *   Egress: true || false, // required
  *   NetworkAclId: "STRING_VALUE", // required
  *   RuleNumber: Number("int"), // required
+ *   Egress: true || false, // required
  * };
  * const command = new DeleteNetworkAclEntryCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/DeleteRouteCommand.d.ts

@@ -35,11 +35,11 @@ declare const DeleteRouteCommand_base: {
  * // const { EC2Client, DeleteRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // DeleteRouteRequest
- *   DestinationCidrBlock: "STRING_VALUE",
- *   DestinationIpv6CidrBlock: "STRING_VALUE",
  *   DestinationPrefixListId: "STRING_VALUE",
  *   DryRun: true || false,
  *   RouteTableId: "STRING_VALUE", // required
+ *   DestinationCidrBlock: "STRING_VALUE",
+ *   DestinationIpv6CidrBlock: "STRING_VALUE",
  * };
  * const command = new DeleteRouteCommand(input);
  * const response = await client.send(command);

package/dist-types/commands/DeleteVpcCommand.d.ts

@@ -27,7 +27,13 @@ declare const DeleteVpcCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Deletes the specified VPC. You must detach or delete all gateways and resources that are associated with the VPC before you can delete it. For example, you must terminate all instances running in the VPC, delete all security groups associated with the VPC (except the default one), delete all route tables associated with the VPC (except the default one), and so on. When you delete the VPC, it deletes the VPC's default security group, network ACL, and route table.</p>
+ * <p>Deletes the specified VPC. You must detach or delete all gateways and resources that are associated
+ * 		  with the VPC before you can delete it. For example, you must terminate all instances running in the VPC,
+ * 		  delete all security groups associated with the VPC (except the default one), delete all route tables
+ * 		  associated with the VPC (except the default one), and so on. When you delete the VPC, it deletes the
+ * 		  default security group, network ACL, and route table for the VPC.</p>
+ *          <p>If you created a flow log for the VPC that you are deleting, note that flow logs for deleted
+ *           VPCs are eventually automatically removed.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/DescribeAccountAttributesCommand.d.ts

@@ -70,10 +70,10 @@ declare const DescribeAccountAttributesCommand_base: {
  * // const { EC2Client, DescribeAccountAttributesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // DescribeAccountAttributesRequest
+ *   DryRun: true || false,
  *   AttributeNames: [ // AccountAttributeNameStringList
  *     "supported-platforms" || "default-vpc",
  *   ],
- *   DryRun: true || false,
  * };
  * const command = new DescribeAccountAttributesCommand(input);
  * const response = await client.send(command);