@aws-sdk/client-direct-connect 3.35.0 → 3.36.0

package/src/commands/AllocateConnectionOnInterconnectCommand.ts

@@ -1,108 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
-import { AllocateConnectionOnInterconnectRequest, Connection } from "../models/models_0";
-import {
-  deserializeAws_json1_1AllocateConnectionOnInterconnectCommand,
-  serializeAws_json1_1AllocateConnectionOnInterconnectCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface AllocateConnectionOnInterconnectCommandInput extends AllocateConnectionOnInterconnectRequest {}
-export interface AllocateConnectionOnInterconnectCommandOutput extends Connection, __MetadataBearer {}
-
-/**
- * @deprecated
- *
- * <p>Deprecated. Use <a>AllocateHostedConnection</a> instead.</p>
- *          <p>Creates a hosted connection on an interconnect.</p>
- *          <p>Allocates a VLAN number and a specified amount of bandwidth for use by a hosted connection on the specified interconnect.</p>
- *          <note>
- *             <p>Intended for use by Direct Connect Partners only.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, AllocateConnectionOnInterconnectCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, AllocateConnectionOnInterconnectCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new AllocateConnectionOnInterconnectCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AllocateConnectionOnInterconnectCommandInput} for command's `input` shape.
- * @see {@link AllocateConnectionOnInterconnectCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AllocateConnectionOnInterconnectCommand extends $Command<
-  AllocateConnectionOnInterconnectCommandInput,
-  AllocateConnectionOnInterconnectCommandOutput,
-  DirectConnectClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AllocateConnectionOnInterconnectCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DirectConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AllocateConnectionOnInterconnectCommandInput, AllocateConnectionOnInterconnectCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DirectConnectClient";
-    const commandName = "AllocateConnectionOnInterconnectCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AllocateConnectionOnInterconnectRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: Connection.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: AllocateConnectionOnInterconnectCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_1AllocateConnectionOnInterconnectCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<AllocateConnectionOnInterconnectCommandOutput> {
-    return deserializeAws_json1_1AllocateConnectionOnInterconnectCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/AllocateHostedConnectionCommand.ts

@@ -1,100 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
-import { AllocateHostedConnectionRequest, Connection } from "../models/models_0";
-import {
-  deserializeAws_json1_1AllocateHostedConnectionCommand,
-  serializeAws_json1_1AllocateHostedConnectionCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface AllocateHostedConnectionCommandInput extends AllocateHostedConnectionRequest {}
-export interface AllocateHostedConnectionCommandOutput extends Connection, __MetadataBearer {}
-
-/**
- * <p>Creates a hosted connection on the specified interconnect or a link aggregation group (LAG) of interconnects.</p>
- *          <p>Allocates a VLAN number and a specified amount of capacity (bandwidth) for use by a hosted connection on the specified interconnect or LAG of interconnects.
- *       Amazon Web Services polices the hosted connection for the specified capacity and the Direct Connect Partner must also police the hosted connection for the specified capacity.</p>
- *          <note>
- *             <p>Intended for use by Direct Connect Partners only.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, AllocateHostedConnectionCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, AllocateHostedConnectionCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new AllocateHostedConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AllocateHostedConnectionCommandInput} for command's `input` shape.
- * @see {@link AllocateHostedConnectionCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AllocateHostedConnectionCommand extends $Command<
-  AllocateHostedConnectionCommandInput,
-  AllocateHostedConnectionCommandOutput,
-  DirectConnectClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AllocateHostedConnectionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DirectConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AllocateHostedConnectionCommandInput, AllocateHostedConnectionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DirectConnectClient";
-    const commandName = "AllocateHostedConnectionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AllocateHostedConnectionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: Connection.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: AllocateHostedConnectionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1AllocateHostedConnectionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<AllocateHostedConnectionCommandOutput> {
-    return deserializeAws_json1_1AllocateHostedConnectionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/AllocatePrivateVirtualInterfaceCommand.ts

@@ -1,103 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
-import { AllocatePrivateVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
-import {
-  deserializeAws_json1_1AllocatePrivateVirtualInterfaceCommand,
-  serializeAws_json1_1AllocatePrivateVirtualInterfaceCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface AllocatePrivateVirtualInterfaceCommandInput extends AllocatePrivateVirtualInterfaceRequest {}
-export interface AllocatePrivateVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {}
-
-/**
- * <p>Provisions a private virtual interface to be owned by the specified account.</p>
- *          <p>Virtual interfaces created using this action must be confirmed by the owner using <a>ConfirmPrivateVirtualInterface</a>.
- *       Until then, the virtual interface is in the <code>Confirming</code> state and is not available to handle traffic.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, AllocatePrivateVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, AllocatePrivateVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new AllocatePrivateVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AllocatePrivateVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link AllocatePrivateVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AllocatePrivateVirtualInterfaceCommand extends $Command<
-  AllocatePrivateVirtualInterfaceCommandInput,
-  AllocatePrivateVirtualInterfaceCommandOutput,
-  DirectConnectClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AllocatePrivateVirtualInterfaceCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DirectConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AllocatePrivateVirtualInterfaceCommandInput, AllocatePrivateVirtualInterfaceCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DirectConnectClient";
-    const commandName = "AllocatePrivateVirtualInterfaceCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AllocatePrivateVirtualInterfaceRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: VirtualInterface.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: AllocatePrivateVirtualInterfaceCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_1AllocatePrivateVirtualInterfaceCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<AllocatePrivateVirtualInterfaceCommandOutput> {
-    return deserializeAws_json1_1AllocatePrivateVirtualInterfaceCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/AllocatePublicVirtualInterfaceCommand.ts

@@ -1,106 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
-import { AllocatePublicVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
-import {
-  deserializeAws_json1_1AllocatePublicVirtualInterfaceCommand,
-  serializeAws_json1_1AllocatePublicVirtualInterfaceCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface AllocatePublicVirtualInterfaceCommandInput extends AllocatePublicVirtualInterfaceRequest {}
-export interface AllocatePublicVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {}
-
-/**
- * <p>Provisions a public virtual interface to be owned by the specified account.</p>
- *          <p>The owner of a connection calls this function to provision a public virtual interface to be owned by the specified account.</p>
- *          <p>Virtual interfaces created using this function must be confirmed by the owner using <a>ConfirmPublicVirtualInterface</a>.
- *       Until this step has been completed, the virtual interface is in the <code>confirming</code> state and is not available to handle traffic.</p>
- *          <p>When creating an IPv6 public virtual interface, omit the Amazon address and customer address. IPv6 addresses are automatically assigned from
- *       the Amazon pool of IPv6 addresses; you cannot specify custom IPv6 addresses.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, AllocatePublicVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, AllocatePublicVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new AllocatePublicVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AllocatePublicVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link AllocatePublicVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AllocatePublicVirtualInterfaceCommand extends $Command<
-  AllocatePublicVirtualInterfaceCommandInput,
-  AllocatePublicVirtualInterfaceCommandOutput,
-  DirectConnectClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AllocatePublicVirtualInterfaceCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DirectConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AllocatePublicVirtualInterfaceCommandInput, AllocatePublicVirtualInterfaceCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DirectConnectClient";
-    const commandName = "AllocatePublicVirtualInterfaceCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AllocatePublicVirtualInterfaceRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: VirtualInterface.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: AllocatePublicVirtualInterfaceCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_1AllocatePublicVirtualInterfaceCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<AllocatePublicVirtualInterfaceCommandOutput> {
-    return deserializeAws_json1_1AllocatePublicVirtualInterfaceCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/AllocateTransitVirtualInterfaceCommand.ts

@@ -1,105 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
-import { AllocateTransitVirtualInterfaceRequest, AllocateTransitVirtualInterfaceResult } from "../models/models_0";
-import {
-  deserializeAws_json1_1AllocateTransitVirtualInterfaceCommand,
-  serializeAws_json1_1AllocateTransitVirtualInterfaceCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface AllocateTransitVirtualInterfaceCommandInput extends AllocateTransitVirtualInterfaceRequest {}
-export interface AllocateTransitVirtualInterfaceCommandOutput
-  extends AllocateTransitVirtualInterfaceResult,
-    __MetadataBearer {}
-
-/**
- * <p>Provisions a transit virtual interface to be owned by the specified account. Use this type of interface to connect a transit gateway to your Direct Connect gateway.</p>
- *          <p>The owner of a connection provisions a transit virtual interface to be owned by the specified account.</p>
- *          <p>After you create a transit virtual interface, it must be confirmed by the owner using <a>ConfirmTransitVirtualInterface</a>. Until this step has been completed, the transit virtual interface is in the <code>requested</code> state and is not available to handle traffic.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, AllocateTransitVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, AllocateTransitVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new AllocateTransitVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AllocateTransitVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link AllocateTransitVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AllocateTransitVirtualInterfaceCommand extends $Command<
-  AllocateTransitVirtualInterfaceCommandInput,
-  AllocateTransitVirtualInterfaceCommandOutput,
-  DirectConnectClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AllocateTransitVirtualInterfaceCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DirectConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AllocateTransitVirtualInterfaceCommandInput, AllocateTransitVirtualInterfaceCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DirectConnectClient";
-    const commandName = "AllocateTransitVirtualInterfaceCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AllocateTransitVirtualInterfaceRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: AllocateTransitVirtualInterfaceResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: AllocateTransitVirtualInterfaceCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_1AllocateTransitVirtualInterfaceCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<AllocateTransitVirtualInterfaceCommandOutput> {
-    return deserializeAws_json1_1AllocateTransitVirtualInterfaceCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/AssociateConnectionWithLagCommand.ts

@@ -1,111 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
-import { AssociateConnectionWithLagRequest, Connection } from "../models/models_0";
-import {
-  deserializeAws_json1_1AssociateConnectionWithLagCommand,
-  serializeAws_json1_1AssociateConnectionWithLagCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface AssociateConnectionWithLagCommandInput extends AssociateConnectionWithLagRequest {}
-export interface AssociateConnectionWithLagCommandOutput extends Connection, __MetadataBearer {}
-
-/**
- * <p>Associates an existing connection with a link aggregation group (LAG). The connection
- *       is interrupted and re-established as a member of the LAG (connectivity to Amazon Web Services is
- *       interrupted). The connection must be hosted on the same Direct Connect endpoint as the LAG, and its
- *       bandwidth must match the bandwidth for the LAG. You can re-associate a connection that's
- *       currently associated with a different LAG; however, if removing the connection would cause
- *       the original LAG to fall below its setting for minimum number of operational connections,
- *       the request fails.</p>
- *          <p>Any virtual interfaces that are directly associated with the connection are
- *       automatically re-associated with the LAG. If the connection was originally associated
- *       with a different LAG, the virtual interfaces remain associated with the original
- *       LAG.</p>
- *          <p>For interconnects, any hosted connections are automatically re-associated with the
- *       LAG. If the interconnect was originally associated with a different LAG, the hosted
- *       connections remain associated with the original LAG.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, AssociateConnectionWithLagCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, AssociateConnectionWithLagCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new AssociateConnectionWithLagCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateConnectionWithLagCommandInput} for command's `input` shape.
- * @see {@link AssociateConnectionWithLagCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AssociateConnectionWithLagCommand extends $Command<
-  AssociateConnectionWithLagCommandInput,
-  AssociateConnectionWithLagCommandOutput,
-  DirectConnectClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AssociateConnectionWithLagCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DirectConnectClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AssociateConnectionWithLagCommandInput, AssociateConnectionWithLagCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DirectConnectClient";
-    const commandName = "AssociateConnectionWithLagCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AssociateConnectionWithLagRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: Connection.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: AssociateConnectionWithLagCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1AssociateConnectionWithLagCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<AssociateConnectionWithLagCommandOutput> {
-    return deserializeAws_json1_1AssociateConnectionWithLagCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}