@aws-sdk/client-ec2 3.50.0 → 3.51.0

package/dist-types/ts3.4/commands/CreateIpamCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateIpamRequest, CreateIpamResult } from "../models/models_1";
+export interface CreateIpamCommandInput extends CreateIpamRequest {
+}
+export interface CreateIpamCommandOutput extends CreateIpamResult, __MetadataBearer {
+}
+
+export declare class CreateIpamCommand extends $Command<CreateIpamCommandInput, CreateIpamCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateIpamCommandInput;
+    constructor(input: CreateIpamCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIpamCommandInput, CreateIpamCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateIpamPoolCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateIpamPoolRequest, CreateIpamPoolResult } from "../models/models_1";
+export interface CreateIpamPoolCommandInput extends CreateIpamPoolRequest {
+}
+export interface CreateIpamPoolCommandOutput extends CreateIpamPoolResult, __MetadataBearer {
+}
+
+export declare class CreateIpamPoolCommand extends $Command<CreateIpamPoolCommandInput, CreateIpamPoolCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateIpamPoolCommandInput;
+    constructor(input: CreateIpamPoolCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIpamPoolCommandInput, CreateIpamPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateIpamScopeCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateIpamScopeRequest, CreateIpamScopeResult } from "../models/models_1";
+export interface CreateIpamScopeCommandInput extends CreateIpamScopeRequest {
+}
+export interface CreateIpamScopeCommandOutput extends CreateIpamScopeResult, __MetadataBearer {
+}
+
+export declare class CreateIpamScopeCommand extends $Command<CreateIpamScopeCommandInput, CreateIpamScopeCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateIpamScopeCommandInput;
+    constructor(input: CreateIpamScopeCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIpamScopeCommandInput, CreateIpamScopeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateKeyPairRequest, KeyPair } from "../models/models_1";
+export interface CreateKeyPairCommandInput extends CreateKeyPairRequest {
+}
+export interface CreateKeyPairCommandOutput extends KeyPair, __MetadataBearer {
+}
+
+export declare class CreateKeyPairCommand extends $Command<CreateKeyPairCommandInput, CreateKeyPairCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateKeyPairCommandInput;
+    constructor(input: CreateKeyPairCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateKeyPairCommandInput, CreateKeyPairCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateLaunchTemplateCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateLaunchTemplateRequest, CreateLaunchTemplateResult } from "../models/models_1";
+export interface CreateLaunchTemplateCommandInput extends CreateLaunchTemplateRequest {
+}
+export interface CreateLaunchTemplateCommandOutput extends CreateLaunchTemplateResult, __MetadataBearer {
+}
+
+export declare class CreateLaunchTemplateCommand extends $Command<CreateLaunchTemplateCommandInput, CreateLaunchTemplateCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateLaunchTemplateCommandInput;
+    constructor(input: CreateLaunchTemplateCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLaunchTemplateCommandInput, CreateLaunchTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateLaunchTemplateVersionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateLaunchTemplateVersionRequest, CreateLaunchTemplateVersionResult } from "../models/models_1";
+export interface CreateLaunchTemplateVersionCommandInput extends CreateLaunchTemplateVersionRequest {
+}
+export interface CreateLaunchTemplateVersionCommandOutput extends CreateLaunchTemplateVersionResult, __MetadataBearer {
+}
+
+export declare class CreateLaunchTemplateVersionCommand extends $Command<CreateLaunchTemplateVersionCommandInput, CreateLaunchTemplateVersionCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateLaunchTemplateVersionCommandInput;
+    constructor(input: CreateLaunchTemplateVersionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLaunchTemplateVersionCommandInput, CreateLaunchTemplateVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateLocalGatewayRouteCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateLocalGatewayRouteRequest, CreateLocalGatewayRouteResult } from "../models/models_1";
+export interface CreateLocalGatewayRouteCommandInput extends CreateLocalGatewayRouteRequest {
+}
+export interface CreateLocalGatewayRouteCommandOutput extends CreateLocalGatewayRouteResult, __MetadataBearer {
+}
+
+export declare class CreateLocalGatewayRouteCommand extends $Command<CreateLocalGatewayRouteCommandInput, CreateLocalGatewayRouteCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateLocalGatewayRouteCommandInput;
+    constructor(input: CreateLocalGatewayRouteCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocalGatewayRouteCommandInput, CreateLocalGatewayRouteCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateLocalGatewayRouteTableVpcAssociationCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateLocalGatewayRouteTableVpcAssociationRequest, CreateLocalGatewayRouteTableVpcAssociationResult } from "../models/models_1";
+export interface CreateLocalGatewayRouteTableVpcAssociationCommandInput extends CreateLocalGatewayRouteTableVpcAssociationRequest {
+}
+export interface CreateLocalGatewayRouteTableVpcAssociationCommandOutput extends CreateLocalGatewayRouteTableVpcAssociationResult, __MetadataBearer {
+}
+
+export declare class CreateLocalGatewayRouteTableVpcAssociationCommand extends $Command<CreateLocalGatewayRouteTableVpcAssociationCommandInput, CreateLocalGatewayRouteTableVpcAssociationCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateLocalGatewayRouteTableVpcAssociationCommandInput;
+    constructor(input: CreateLocalGatewayRouteTableVpcAssociationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocalGatewayRouteTableVpcAssociationCommandInput, CreateLocalGatewayRouteTableVpcAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateManagedPrefixListCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateManagedPrefixListRequest, CreateManagedPrefixListResult } from "../models/models_1";
+export interface CreateManagedPrefixListCommandInput extends CreateManagedPrefixListRequest {
+}
+export interface CreateManagedPrefixListCommandOutput extends CreateManagedPrefixListResult, __MetadataBearer {
+}
+
+export declare class CreateManagedPrefixListCommand extends $Command<CreateManagedPrefixListCommandInput, CreateManagedPrefixListCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateManagedPrefixListCommandInput;
+    constructor(input: CreateManagedPrefixListCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateManagedPrefixListCommandInput, CreateManagedPrefixListCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateNatGatewayRequest, CreateNatGatewayResult } from "../models/models_1";
+export interface CreateNatGatewayCommandInput extends CreateNatGatewayRequest {
+}
+export interface CreateNatGatewayCommandOutput extends CreateNatGatewayResult, __MetadataBearer {
+}
+
+export declare class CreateNatGatewayCommand extends $Command<CreateNatGatewayCommandInput, CreateNatGatewayCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateNatGatewayCommandInput;
+    constructor(input: CreateNatGatewayCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNatGatewayCommandInput, CreateNatGatewayCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateNetworkAclRequest, CreateNetworkAclResult } from "../models/models_1";
+export interface CreateNetworkAclCommandInput extends CreateNetworkAclRequest {
+}
+export interface CreateNetworkAclCommandOutput extends CreateNetworkAclResult, __MetadataBearer {
+}
+
+export declare class CreateNetworkAclCommand extends $Command<CreateNetworkAclCommandInput, CreateNetworkAclCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateNetworkAclCommandInput;
+    constructor(input: CreateNetworkAclCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkAclCommandInput, CreateNetworkAclCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateNetworkAclEntryRequest } from "../models/models_1";
+export interface CreateNetworkAclEntryCommandInput extends CreateNetworkAclEntryRequest {
+}
+export interface CreateNetworkAclEntryCommandOutput extends __MetadataBearer {
+}
+
+export declare class CreateNetworkAclEntryCommand extends $Command<CreateNetworkAclEntryCommandInput, CreateNetworkAclEntryCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateNetworkAclEntryCommandInput;
+    constructor(input: CreateNetworkAclEntryCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkAclEntryCommandInput, CreateNetworkAclEntryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateNetworkInsightsAccessScopeCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateNetworkInsightsAccessScopeRequest, CreateNetworkInsightsAccessScopeResult } from "../models/models_1";
+export interface CreateNetworkInsightsAccessScopeCommandInput extends CreateNetworkInsightsAccessScopeRequest {
+}
+export interface CreateNetworkInsightsAccessScopeCommandOutput extends CreateNetworkInsightsAccessScopeResult, __MetadataBearer {
+}
+
+export declare class CreateNetworkInsightsAccessScopeCommand extends $Command<CreateNetworkInsightsAccessScopeCommandInput, CreateNetworkInsightsAccessScopeCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateNetworkInsightsAccessScopeCommandInput;
+    constructor(input: CreateNetworkInsightsAccessScopeCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInsightsAccessScopeCommandInput, CreateNetworkInsightsAccessScopeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateNetworkInsightsPathCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateNetworkInsightsPathRequest, CreateNetworkInsightsPathResult } from "../models/models_1";
+export interface CreateNetworkInsightsPathCommandInput extends CreateNetworkInsightsPathRequest {
+}
+export interface CreateNetworkInsightsPathCommandOutput extends CreateNetworkInsightsPathResult, __MetadataBearer {
+}
+
+export declare class CreateNetworkInsightsPathCommand extends $Command<CreateNetworkInsightsPathCommandInput, CreateNetworkInsightsPathCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateNetworkInsightsPathCommandInput;
+    constructor(input: CreateNetworkInsightsPathCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInsightsPathCommandInput, CreateNetworkInsightsPathCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateNetworkInterfaceRequest, CreateNetworkInterfaceResult } from "../models/models_1";
+export interface CreateNetworkInterfaceCommandInput extends CreateNetworkInterfaceRequest {
+}
+export interface CreateNetworkInterfaceCommandOutput extends CreateNetworkInterfaceResult, __MetadataBearer {
+}
+
+export declare class CreateNetworkInterfaceCommand extends $Command<CreateNetworkInterfaceCommandInput, CreateNetworkInterfaceCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateNetworkInterfaceCommandInput;
+    constructor(input: CreateNetworkInterfaceCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInterfaceCommandInput, CreateNetworkInterfaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateNetworkInterfacePermissionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateNetworkInterfacePermissionRequest, CreateNetworkInterfacePermissionResult } from "../models/models_1";
+export interface CreateNetworkInterfacePermissionCommandInput extends CreateNetworkInterfacePermissionRequest {
+}
+export interface CreateNetworkInterfacePermissionCommandOutput extends CreateNetworkInterfacePermissionResult, __MetadataBearer {
+}
+
+export declare class CreateNetworkInterfacePermissionCommand extends $Command<CreateNetworkInterfacePermissionCommandInput, CreateNetworkInterfacePermissionCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateNetworkInterfacePermissionCommandInput;
+    constructor(input: CreateNetworkInterfacePermissionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInterfacePermissionCommandInput, CreateNetworkInterfacePermissionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreatePlacementGroupRequest, CreatePlacementGroupResult } from "../models/models_1";
+export interface CreatePlacementGroupCommandInput extends CreatePlacementGroupRequest {
+}
+export interface CreatePlacementGroupCommandOutput extends CreatePlacementGroupResult, __MetadataBearer {
+}
+
+export declare class CreatePlacementGroupCommand extends $Command<CreatePlacementGroupCommandInput, CreatePlacementGroupCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreatePlacementGroupCommandInput;
+    constructor(input: CreatePlacementGroupCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePlacementGroupCommandInput, CreatePlacementGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreatePublicIpv4PoolCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreatePublicIpv4PoolRequest, CreatePublicIpv4PoolResult } from "../models/models_1";
+export interface CreatePublicIpv4PoolCommandInput extends CreatePublicIpv4PoolRequest {
+}
+export interface CreatePublicIpv4PoolCommandOutput extends CreatePublicIpv4PoolResult, __MetadataBearer {
+}
+
+export declare class CreatePublicIpv4PoolCommand extends $Command<CreatePublicIpv4PoolCommandInput, CreatePublicIpv4PoolCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreatePublicIpv4PoolCommandInput;
+    constructor(input: CreatePublicIpv4PoolCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePublicIpv4PoolCommandInput, CreatePublicIpv4PoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateReplaceRootVolumeTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateReplaceRootVolumeTaskRequest, CreateReplaceRootVolumeTaskResult } from "../models/models_1";
+export interface CreateReplaceRootVolumeTaskCommandInput extends CreateReplaceRootVolumeTaskRequest {
+}
+export interface CreateReplaceRootVolumeTaskCommandOutput extends CreateReplaceRootVolumeTaskResult, __MetadataBearer {
+}
+
+export declare class CreateReplaceRootVolumeTaskCommand extends $Command<CreateReplaceRootVolumeTaskCommandInput, CreateReplaceRootVolumeTaskCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateReplaceRootVolumeTaskCommandInput;
+    constructor(input: CreateReplaceRootVolumeTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateReplaceRootVolumeTaskCommandInput, CreateReplaceRootVolumeTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateReservedInstancesListingRequest, CreateReservedInstancesListingResult } from "../models/models_1";
+export interface CreateReservedInstancesListingCommandInput extends CreateReservedInstancesListingRequest {
+}
+export interface CreateReservedInstancesListingCommandOutput extends CreateReservedInstancesListingResult, __MetadataBearer {
+}
+
+export declare class CreateReservedInstancesListingCommand extends $Command<CreateReservedInstancesListingCommandInput, CreateReservedInstancesListingCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateReservedInstancesListingCommandInput;
+    constructor(input: CreateReservedInstancesListingCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateReservedInstancesListingCommandInput, CreateReservedInstancesListingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateRestoreImageTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateRestoreImageTaskRequest, CreateRestoreImageTaskResult } from "../models/models_1";
+export interface CreateRestoreImageTaskCommandInput extends CreateRestoreImageTaskRequest {
+}
+export interface CreateRestoreImageTaskCommandOutput extends CreateRestoreImageTaskResult, __MetadataBearer {
+}
+
+export declare class CreateRestoreImageTaskCommand extends $Command<CreateRestoreImageTaskCommandInput, CreateRestoreImageTaskCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateRestoreImageTaskCommandInput;
+    constructor(input: CreateRestoreImageTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRestoreImageTaskCommandInput, CreateRestoreImageTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateRouteRequest, CreateRouteResult } from "../models/models_1";
+export interface CreateRouteCommandInput extends CreateRouteRequest {
+}
+export interface CreateRouteCommandOutput extends CreateRouteResult, __MetadataBearer {
+}
+
+export declare class CreateRouteCommand extends $Command<CreateRouteCommandInput, CreateRouteCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateRouteCommandInput;
+    constructor(input: CreateRouteCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRouteCommandInput, CreateRouteCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateRouteTableRequest, CreateRouteTableResult } from "../models/models_1";
+export interface CreateRouteTableCommandInput extends CreateRouteTableRequest {
+}
+export interface CreateRouteTableCommandOutput extends CreateRouteTableResult, __MetadataBearer {
+}
+
+export declare class CreateRouteTableCommand extends $Command<CreateRouteTableCommandInput, CreateRouteTableCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateRouteTableCommandInput;
+    constructor(input: CreateRouteTableCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRouteTableCommandInput, CreateRouteTableCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateSecurityGroupCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateSecurityGroupRequest, CreateSecurityGroupResult } from "../models/models_1";
+export interface CreateSecurityGroupCommandInput extends CreateSecurityGroupRequest {
+}
+export interface CreateSecurityGroupCommandOutput extends CreateSecurityGroupResult, __MetadataBearer {
+}
+
+export declare class CreateSecurityGroupCommand extends $Command<CreateSecurityGroupCommandInput, CreateSecurityGroupCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateSecurityGroupCommandInput;
+    constructor(input: CreateSecurityGroupCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSecurityGroupCommandInput, CreateSecurityGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateSnapshotRequest, Snapshot } from "../models/models_1";
+export interface CreateSnapshotCommandInput extends CreateSnapshotRequest {
+}
+export interface CreateSnapshotCommandOutput extends Snapshot, __MetadataBearer {
+}
+
+export declare class CreateSnapshotCommand extends $Command<CreateSnapshotCommandInput, CreateSnapshotCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateSnapshotCommandInput;
+    constructor(input: CreateSnapshotCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotCommandInput, CreateSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateSnapshotsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateSnapshotsRequest, CreateSnapshotsResult } from "../models/models_1";
+export interface CreateSnapshotsCommandInput extends CreateSnapshotsRequest {
+}
+export interface CreateSnapshotsCommandOutput extends CreateSnapshotsResult, __MetadataBearer {
+}
+
+export declare class CreateSnapshotsCommand extends $Command<CreateSnapshotsCommandInput, CreateSnapshotsCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateSnapshotsCommandInput;
+    constructor(input: CreateSnapshotsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotsCommandInput, CreateSnapshotsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateSpotDatafeedSubscriptionRequest, CreateSpotDatafeedSubscriptionResult } from "../models/models_1";
+export interface CreateSpotDatafeedSubscriptionCommandInput extends CreateSpotDatafeedSubscriptionRequest {
+}
+export interface CreateSpotDatafeedSubscriptionCommandOutput extends CreateSpotDatafeedSubscriptionResult, __MetadataBearer {
+}
+
+export declare class CreateSpotDatafeedSubscriptionCommand extends $Command<CreateSpotDatafeedSubscriptionCommandInput, CreateSpotDatafeedSubscriptionCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateSpotDatafeedSubscriptionCommandInput;
+    constructor(input: CreateSpotDatafeedSubscriptionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSpotDatafeedSubscriptionCommandInput, CreateSpotDatafeedSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateStoreImageTaskCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateStoreImageTaskRequest, CreateStoreImageTaskResult } from "../models/models_1";
+export interface CreateStoreImageTaskCommandInput extends CreateStoreImageTaskRequest {
+}
+export interface CreateStoreImageTaskCommandOutput extends CreateStoreImageTaskResult, __MetadataBearer {
+}
+
+export declare class CreateStoreImageTaskCommand extends $Command<CreateStoreImageTaskCommandInput, CreateStoreImageTaskCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateStoreImageTaskCommandInput;
+    constructor(input: CreateStoreImageTaskCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStoreImageTaskCommandInput, CreateStoreImageTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateSubnetCidrReservationRequest, CreateSubnetCidrReservationResult } from "../models/models_1";
+export interface CreateSubnetCidrReservationCommandInput extends CreateSubnetCidrReservationRequest {
+}
+export interface CreateSubnetCidrReservationCommandOutput extends CreateSubnetCidrReservationResult, __MetadataBearer {
+}
+
+export declare class CreateSubnetCidrReservationCommand extends $Command<CreateSubnetCidrReservationCommandInput, CreateSubnetCidrReservationCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateSubnetCidrReservationCommandInput;
+    constructor(input: CreateSubnetCidrReservationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubnetCidrReservationCommandInput, CreateSubnetCidrReservationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateSubnetRequest, CreateSubnetResult } from "../models/models_1";
+export interface CreateSubnetCommandInput extends CreateSubnetRequest {
+}
+export interface CreateSubnetCommandOutput extends CreateSubnetResult, __MetadataBearer {
+}
+
+export declare class CreateSubnetCommand extends $Command<CreateSubnetCommandInput, CreateSubnetCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateSubnetCommandInput;
+    constructor(input: CreateSubnetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubnetCommandInput, CreateSubnetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateTagsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateTagsRequest } from "../models/models_1";
+export interface CreateTagsCommandInput extends CreateTagsRequest {
+}
+export interface CreateTagsCommandOutput extends __MetadataBearer {
+}
+
+export declare class CreateTagsCommand extends $Command<CreateTagsCommandInput, CreateTagsCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateTagsCommandInput;
+    constructor(input: CreateTagsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTagsCommandInput, CreateTagsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateTrafficMirrorFilterCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { CreateTrafficMirrorFilterRequest, CreateTrafficMirrorFilterResult } from "../models/models_1";
+export interface CreateTrafficMirrorFilterCommandInput extends CreateTrafficMirrorFilterRequest {
+}
+export interface CreateTrafficMirrorFilterCommandOutput extends CreateTrafficMirrorFilterResult, __MetadataBearer {
+}
+
+export declare class CreateTrafficMirrorFilterCommand extends $Command<CreateTrafficMirrorFilterCommandInput, CreateTrafficMirrorFilterCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: CreateTrafficMirrorFilterCommandInput;
+    constructor(input: CreateTrafficMirrorFilterCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorFilterCommandInput, CreateTrafficMirrorFilterCommandOutput>;
+    private serialize;
+    private deserialize;
+}