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

package/src/commands/ConfirmTransitVirtualInterfaceCommand.ts

@@ -0,0 +1,105 @@
+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 { ConfirmTransitVirtualInterfaceRequest, ConfirmTransitVirtualInterfaceResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1ConfirmTransitVirtualInterfaceCommand,
+  serializeAws_json1_1ConfirmTransitVirtualInterfaceCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface ConfirmTransitVirtualInterfaceCommandInput extends ConfirmTransitVirtualInterfaceRequest {}
+export interface ConfirmTransitVirtualInterfaceCommandOutput
+  extends ConfirmTransitVirtualInterfaceResponse,
+    __MetadataBearer {}
+
+/**
+ * <p>Accepts ownership of a transit virtual interface created by another account.</p>
+ *
+ *          <p> After the owner of the transit virtual interface makes this call, the specified transit virtual interface is created and made available to handle traffic.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, ConfirmTransitVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, ConfirmTransitVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new ConfirmTransitVirtualInterfaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ConfirmTransitVirtualInterfaceCommandInput} for command's `input` shape.
+ * @see {@link ConfirmTransitVirtualInterfaceCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ConfirmTransitVirtualInterfaceCommand extends $Command<
+  ConfirmTransitVirtualInterfaceCommandInput,
+  ConfirmTransitVirtualInterfaceCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ConfirmTransitVirtualInterfaceCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ConfirmTransitVirtualInterfaceCommandInput, ConfirmTransitVirtualInterfaceCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "ConfirmTransitVirtualInterfaceCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ConfirmTransitVirtualInterfaceRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ConfirmTransitVirtualInterfaceResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(
+    input: ConfirmTransitVirtualInterfaceCommandInput,
+    context: __SerdeContext
+  ): Promise<__HttpRequest> {
+    return serializeAws_json1_1ConfirmTransitVirtualInterfaceCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<ConfirmTransitVirtualInterfaceCommandOutput> {
+    return deserializeAws_json1_1ConfirmTransitVirtualInterfaceCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateBGPPeerCommand.ts

@@ -0,0 +1,101 @@
+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 { CreateBGPPeerRequest, CreateBGPPeerResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateBGPPeerCommand,
+  serializeAws_json1_1CreateBGPPeerCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateBGPPeerCommandInput extends CreateBGPPeerRequest {}
+export interface CreateBGPPeerCommandOutput extends CreateBGPPeerResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates a BGP peer on the specified virtual interface.</p>
+ *          <p>You must create a BGP peer for the corresponding address family (IPv4/IPv6) in order to access Amazon Web Services resources that also use that address family.</p>
+ *          <p>If logical redundancy is not supported by the connection, interconnect, or LAG, the BGP peer cannot
+ *       be in the same address family as an existing BGP peer on the virtual interface.</p>
+ *          <p>When creating a IPv6 BGP peer, 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>
+ *          <p>For a public virtual interface, the Autonomous System Number (ASN) must be private or already on the allow list for the virtual interface.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, CreateBGPPeerCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, CreateBGPPeerCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new CreateBGPPeerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateBGPPeerCommandInput} for command's `input` shape.
+ * @see {@link CreateBGPPeerCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateBGPPeerCommand extends $Command<
+  CreateBGPPeerCommandInput,
+  CreateBGPPeerCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateBGPPeerCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateBGPPeerCommandInput, CreateBGPPeerCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "CreateBGPPeerCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateBGPPeerRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateBGPPeerResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateBGPPeerCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateBGPPeerCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateBGPPeerCommandOutput> {
+    return deserializeAws_json1_1CreateBGPPeerCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateConnectionCommand.ts

@@ -0,0 +1,103 @@
+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 { Connection, CreateConnectionRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateConnectionCommand,
+  serializeAws_json1_1CreateConnectionCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateConnectionCommandInput extends CreateConnectionRequest {}
+export interface CreateConnectionCommandOutput extends Connection, __MetadataBearer {}
+
+/**
+ * <p>Creates a connection between a customer network and a specific Direct Connect location.</p>
+ *
+ *          <p>A connection links your internal network to an Direct Connect location over a standard Ethernet fiber-optic
+ *       cable. One end of the cable is connected to your router, the other to an Direct Connect router.</p>
+ *          <p>To find the locations for your Region, use <a>DescribeLocations</a>.</p>
+ *          <p>You can automatically add the new connection to a link aggregation group (LAG) by
+ *       specifying a LAG ID in the request. This ensures that the new connection is allocated on the
+ *       same Direct Connect endpoint that hosts the specified LAG. If there are no available ports on the endpoint,
+ *       the request fails and no connection is created.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, CreateConnectionCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, CreateConnectionCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new CreateConnectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateConnectionCommandInput} for command's `input` shape.
+ * @see {@link CreateConnectionCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateConnectionCommand extends $Command<
+  CreateConnectionCommandInput,
+  CreateConnectionCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateConnectionCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateConnectionCommandInput, CreateConnectionCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "CreateConnectionCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateConnectionRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: Connection.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateConnectionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateConnectionCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateConnectionCommandOutput> {
+    return deserializeAws_json1_1CreateConnectionCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateDirectConnectGatewayAssociationCommand.ts

@@ -0,0 +1,108 @@
+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 {
+  CreateDirectConnectGatewayAssociationRequest,
+  CreateDirectConnectGatewayAssociationResult,
+} from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateDirectConnectGatewayAssociationCommand,
+  serializeAws_json1_1CreateDirectConnectGatewayAssociationCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateDirectConnectGatewayAssociationCommandInput
+  extends CreateDirectConnectGatewayAssociationRequest {}
+export interface CreateDirectConnectGatewayAssociationCommandOutput
+  extends CreateDirectConnectGatewayAssociationResult,
+    __MetadataBearer {}
+
+/**
+ * <p>Creates an association between a Direct Connect gateway and a virtual private gateway. The virtual
+ *       private gateway must be attached to a VPC and must not be associated with another Direct Connect gateway.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, CreateDirectConnectGatewayAssociationCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, CreateDirectConnectGatewayAssociationCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new CreateDirectConnectGatewayAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDirectConnectGatewayAssociationCommandInput} for command's `input` shape.
+ * @see {@link CreateDirectConnectGatewayAssociationCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateDirectConnectGatewayAssociationCommand extends $Command<
+  CreateDirectConnectGatewayAssociationCommandInput,
+  CreateDirectConnectGatewayAssociationCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateDirectConnectGatewayAssociationCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateDirectConnectGatewayAssociationCommandInput, CreateDirectConnectGatewayAssociationCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "CreateDirectConnectGatewayAssociationCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateDirectConnectGatewayAssociationRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateDirectConnectGatewayAssociationResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(
+    input: CreateDirectConnectGatewayAssociationCommandInput,
+    context: __SerdeContext
+  ): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateDirectConnectGatewayAssociationCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<CreateDirectConnectGatewayAssociationCommandOutput> {
+    return deserializeAws_json1_1CreateDirectConnectGatewayAssociationCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateDirectConnectGatewayAssociationProposalCommand.ts

@@ -0,0 +1,111 @@
+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 {
+  CreateDirectConnectGatewayAssociationProposalRequest,
+  CreateDirectConnectGatewayAssociationProposalResult,
+} from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand,
+  serializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateDirectConnectGatewayAssociationProposalCommandInput
+  extends CreateDirectConnectGatewayAssociationProposalRequest {}
+export interface CreateDirectConnectGatewayAssociationProposalCommandOutput
+  extends CreateDirectConnectGatewayAssociationProposalResult,
+    __MetadataBearer {}
+
+/**
+ * <p>Creates a proposal to associate the specified virtual private gateway or transit gateway with the specified Direct Connect gateway.</p>
+ *          <p>You can associate a Direct Connect gateway and virtual private gateway or transit gateway that is owned by any account. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, CreateDirectConnectGatewayAssociationProposalCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, CreateDirectConnectGatewayAssociationProposalCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new CreateDirectConnectGatewayAssociationProposalCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDirectConnectGatewayAssociationProposalCommandInput} for command's `input` shape.
+ * @see {@link CreateDirectConnectGatewayAssociationProposalCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateDirectConnectGatewayAssociationProposalCommand extends $Command<
+  CreateDirectConnectGatewayAssociationProposalCommandInput,
+  CreateDirectConnectGatewayAssociationProposalCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateDirectConnectGatewayAssociationProposalCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<
+    CreateDirectConnectGatewayAssociationProposalCommandInput,
+    CreateDirectConnectGatewayAssociationProposalCommandOutput
+  > {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "CreateDirectConnectGatewayAssociationProposalCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateDirectConnectGatewayAssociationProposalRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateDirectConnectGatewayAssociationProposalResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(
+    input: CreateDirectConnectGatewayAssociationProposalCommandInput,
+    context: __SerdeContext
+  ): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<CreateDirectConnectGatewayAssociationProposalCommandOutput> {
+    return deserializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateDirectConnectGatewayCommand.ts

@@ -0,0 +1,103 @@
+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 { CreateDirectConnectGatewayRequest, CreateDirectConnectGatewayResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateDirectConnectGatewayCommand,
+  serializeAws_json1_1CreateDirectConnectGatewayCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateDirectConnectGatewayCommandInput extends CreateDirectConnectGatewayRequest {}
+export interface CreateDirectConnectGatewayCommandOutput extends CreateDirectConnectGatewayResult, __MetadataBearer {}
+
+/**
+ * <p>Creates a Direct Connect gateway, which is an intermediate object that enables you to connect a set
+ *       of virtual interfaces and virtual private gateways. A Direct Connect gateway is global and visible in any
+ *       Region after it is created. The virtual interfaces and virtual private gateways that
+ *       are connected through a Direct Connect gateway can be in different Regions. This enables you to
+ *       connect to a VPC in any Region, regardless of the Region in which the virtual interfaces
+ *       are located, and pass traffic between them.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, CreateDirectConnectGatewayCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, CreateDirectConnectGatewayCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new CreateDirectConnectGatewayCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDirectConnectGatewayCommandInput} for command's `input` shape.
+ * @see {@link CreateDirectConnectGatewayCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateDirectConnectGatewayCommand extends $Command<
+  CreateDirectConnectGatewayCommandInput,
+  CreateDirectConnectGatewayCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateDirectConnectGatewayCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateDirectConnectGatewayCommandInput, CreateDirectConnectGatewayCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "CreateDirectConnectGatewayCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateDirectConnectGatewayRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateDirectConnectGatewayResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateDirectConnectGatewayCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateDirectConnectGatewayCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<CreateDirectConnectGatewayCommandOutput> {
+    return deserializeAws_json1_1CreateDirectConnectGatewayCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}