@aws-sdk/client-ec2 3.664.0 → 3.666.0

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

@@ -29,7 +29,7 @@ declare const CreateDefaultSubnetCommand_base: {
 /**
  * <p>Creates a default subnet with a size <code>/20</code> IPv4 CIDR block in the
  *             specified Availability Zone in your default VPC. You can have only one default subnet
- *             per Availability Zone. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-subnet">Create a default
+ *             per Availability Zone. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/work-with-default-vpc.html#create-default-subnet">Create a default
  *                 subnet</a> in the <i>Amazon VPC User Guide</i>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -46,18 +46,10 @@ declare const CreateDefaultSubnetCommand_base: {
  * const response = await client.send(command);
  * // { // CreateDefaultSubnetResult
  * //   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
@@ -87,6 +79,14 @@ declare const CreateDefaultSubnetCommand_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/CreateDefaultVpcCommand.d.ts

@@ -47,10 +47,6 @@ declare const CreateDefaultVpcCommand_base: {
  * const response = await client.send(command);
  * // { // CreateDefaultVpcResult
  * //   Vpc: { // Vpc
- * //     CidrBlock: "STRING_VALUE",
- * //     DhcpOptionsId: "STRING_VALUE",
- * //     State: "pending" || "available",
- * //     VpcId: "STRING_VALUE",
  * //     OwnerId: "STRING_VALUE",
  * //     InstanceTenancy: "default" || "dedicated" || "host",
  * //     Ipv6CidrBlockAssociationSet: [ // VpcIpv6CidrBlockAssociationSet
@@ -84,6 +80,10 @@ declare const CreateDefaultVpcCommand_base: {
  * //         Value: "STRING_VALUE",
  * //       },
  * //     ],
+ * //     VpcId: "STRING_VALUE",
+ * //     State: "pending" || "available",
+ * //     CidrBlock: "STRING_VALUE",
+ * //     DhcpOptionsId: "STRING_VALUE",
  * //   },
  * // };
  *

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

@@ -109,6 +109,14 @@ declare const CreateDhcpOptionsCommand_base: {
  * const response = await client.send(command);
  * // { // CreateDhcpOptionsResult
  * //   DhcpOptions: { // DhcpOptions
+ * //     OwnerId: "STRING_VALUE",
+ * //     Tags: [ // TagList
+ * //       { // Tag
+ * //         Key: "STRING_VALUE",
+ * //         Value: "STRING_VALUE",
+ * //       },
+ * //     ],
+ * //     DhcpOptionsId: "STRING_VALUE",
  * //     DhcpConfigurations: [ // DhcpConfigurationList
  * //       { // DhcpConfiguration
  * //         Key: "STRING_VALUE",
@@ -119,14 +127,6 @@ declare const CreateDhcpOptionsCommand_base: {
  * //         ],
  * //       },
  * //     ],
- * //     DhcpOptionsId: "STRING_VALUE",
- * //     OwnerId: "STRING_VALUE",
- * //     Tags: [ // TagList
- * //       { // Tag
- * //         Key: "STRING_VALUE",
- * //         Value: "STRING_VALUE",
- * //       },
- * //     ],
  * //   },
  * // };
  *

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

@@ -83,7 +83,6 @@ declare const CreateFleetCommand_base: {
  *           WeightedCapacity: Number("double"),
  *           Priority: Number("double"),
  *           Placement: { // Placement
- *             AvailabilityZone: "STRING_VALUE",
  *             Affinity: "STRING_VALUE",
  *             GroupName: "STRING_VALUE",
  *             PartitionNumber: Number("int"),
@@ -92,6 +91,7 @@ declare const CreateFleetCommand_base: {
  *             SpreadDomain: "STRING_VALUE",
  *             HostResourceGroupArn: "STRING_VALUE",
  *             GroupId: "STRING_VALUE",
+ *             AvailabilityZone: "STRING_VALUE",
  *           },
  *           InstanceRequirements: { // InstanceRequirementsRequest
  *             VCpuCount: { // VCpuCountRangeRequest

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

@@ -31,7 +31,7 @@ declare const CreateFlowLogsCommand_base: {
  *             subnet, or VPC. </p>
  *          <p>Flow log data for a monitored network interface is recorded as flow log records, which are log events
  *             consisting of fields that describe the traffic flow. For more information, see
- *             <a href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records">Flow log records</a>
+ *             <a href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-log-records.html">Flow log records</a>
  *             in the <i>Amazon VPC User Guide</i>.</p>
  *          <p>When publishing to CloudWatch Logs, flow log records are published to a log group, and each network
  *             interface has a unique log stream in the log group. When publishing to Amazon S3, flow log records for all

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

@@ -41,10 +41,24 @@ declare const CreateImageCommand_base: {
  * // const { EC2Client, CreateImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateImageRequest
+ *   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,
+ *   InstanceId: "STRING_VALUE", // required
+ *   Name: "STRING_VALUE", // required
+ *   Description: "STRING_VALUE",
+ *   NoReboot: true || false,
  *   BlockDeviceMappings: [ // BlockDeviceMappingRequestList
  *     { // BlockDeviceMapping
- *       DeviceName: "STRING_VALUE",
- *       VirtualName: "STRING_VALUE",
  *       Ebs: { // EbsBlockDevice
  *         DeleteOnTermination: true || false,
  *         Iops: Number("int"),
@@ -57,22 +71,8 @@ declare const CreateImageCommand_base: {
  *         Encrypted: true || false,
  *       },
  *       NoDevice: "STRING_VALUE",
- *     },
- *   ],
- *   Description: "STRING_VALUE",
- *   DryRun: true || false,
- *   InstanceId: "STRING_VALUE", // required
- *   Name: "STRING_VALUE", // required
- *   NoReboot: 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",
- *         },
- *       ],
+ *       DeviceName: "STRING_VALUE",
+ *       VirtualName: "STRING_VALUE",
  *     },
  *   ],
  * };

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

@@ -38,15 +38,6 @@ declare const CreateInstanceExportTaskCommand_base: {
  * // const { EC2Client, CreateInstanceExportTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateInstanceExportTaskRequest
- *   Description: "STRING_VALUE",
- *   ExportToS3Task: { // ExportToS3TaskSpecification
- *     ContainerFormat: "ova",
- *     DiskImageFormat: "VMDK" || "RAW" || "VHD",
- *     S3Bucket: "STRING_VALUE",
- *     S3Prefix: "STRING_VALUE",
- *   },
- *   InstanceId: "STRING_VALUE", // required
- *   TargetEnvironment: "citrix" || "vmware" || "microsoft", // 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",
@@ -58,6 +49,15 @@ declare const CreateInstanceExportTaskCommand_base: {
  *       ],
  *     },
  *   ],
+ *   Description: "STRING_VALUE",
+ *   InstanceId: "STRING_VALUE", // required
+ *   TargetEnvironment: "citrix" || "vmware" || "microsoft", // required
+ *   ExportToS3Task: { // ExportToS3TaskSpecification
+ *     DiskImageFormat: "VMDK" || "RAW" || "VHD",
+ *     ContainerFormat: "ova",
+ *     S3Bucket: "STRING_VALUE",
+ *     S3Prefix: "STRING_VALUE",
+ *   },
  * };
  * const command = new CreateInstanceExportTaskCommand(input);
  * const response = await client.send(command);

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

@@ -46,7 +46,6 @@ declare const CreateKeyPairCommand_base: {
  * const client = new EC2Client(config);
  * const input = { // CreateKeyPairRequest
  *   KeyName: "STRING_VALUE", // required
- *   DryRun: true || false,
  *   KeyType: "rsa" || "ed25519",
  *   TagSpecifications: [ // TagSpecificationList
  *     { // TagSpecification
@@ -60,13 +59,11 @@ declare const CreateKeyPairCommand_base: {
  *     },
  *   ],
  *   KeyFormat: "pem" || "ppk",
+ *   DryRun: true || false,
  * };
  * const command = new CreateKeyPairCommand(input);
  * const response = await client.send(command);
  * // { // KeyPair
- * //   KeyFingerprint: "STRING_VALUE",
- * //   KeyMaterial: "STRING_VALUE",
- * //   KeyName: "STRING_VALUE",
  * //   KeyPairId: "STRING_VALUE",
  * //   Tags: [ // TagList
  * //     { // Tag
@@ -74,6 +71,9 @@ declare const CreateKeyPairCommand_base: {
  * //       Value: "STRING_VALUE",
  * //     },
  * //   ],
+ * //   KeyName: "STRING_VALUE",
+ * //   KeyFingerprint: "STRING_VALUE",
+ * //   KeyMaterial: "STRING_VALUE",
  * // };
  *
  * ```

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

@@ -38,7 +38,13 @@ declare const CreateNatGatewayCommand_base: {
  *             private IPv4 addresses, and communicating between overlapping networks.</p>
  *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html">NAT gateways</a> in the <i>Amazon VPC User Guide</i>.</p>
  *          <important>
- *             <p>When you create a public NAT gateway and assign it an EIP or secondary EIPs, the network border group of the EIPs must match the network border group of the Availability Zone (AZ) that the public NAT gateway is in. If it's not the same, the NAT gateway will fail to launch. You can see the network border group for the subnet's AZ by viewing the details of the subnet. Similarly, you can view the network border group of an EIP by viewing the details of the EIP address. For more information about network border groups and EIPs, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#allocate-eip">Allocate an Elastic IP address</a> in the <i>Amazon VPC User Guide</i>.
+ *             <p>When you create a public NAT gateway and assign it an EIP or secondary EIPs,
+ *           the network border group of the EIPs must match the network border group of the Availability Zone (AZ)
+ *           that the public NAT gateway is in. If it's not the same, the NAT gateway will fail to launch.
+ *           You can see the network border group for the subnet's AZ by viewing the details of the subnet.
+ *           Similarly, you can view the network border group of an EIP by viewing the details of the EIP address.
+ *           For more information about network border groups and EIPs, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html">Allocate an Elastic IP address</a>
+ *           in the <i>Amazon VPC User Guide</i>.
  *       </p>
  *          </important>
  * @example

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

@@ -37,8 +37,6 @@ declare const CreateNetworkAclCommand_base: {
  * // const { EC2Client, CreateNetworkAclCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
  * const client = new EC2Client(config);
  * const input = { // CreateNetworkAclRequest
- *   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 CreateNetworkAclCommand_base: {
  *     },
  *   ],
  *   ClientToken: "STRING_VALUE",
+ *   DryRun: true || false,
+ *   VpcId: "STRING_VALUE", // required
  * };
  * const command = new CreateNetworkAclCommand(input);
  * const response = await client.send(command);

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,
  * //   },
  * // };
  *