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

package/src/commands/DescribeDirectConnectGatewayAttachmentsCommand.ts

@@ -0,0 +1,114 @@
+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 {
+  DescribeDirectConnectGatewayAttachmentsRequest,
+  DescribeDirectConnectGatewayAttachmentsResult,
+} from "../models/models_0";
+import {
+  deserializeAws_json1_1DescribeDirectConnectGatewayAttachmentsCommand,
+  serializeAws_json1_1DescribeDirectConnectGatewayAttachmentsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DescribeDirectConnectGatewayAttachmentsCommandInput
+  extends DescribeDirectConnectGatewayAttachmentsRequest {}
+export interface DescribeDirectConnectGatewayAttachmentsCommandOutput
+  extends DescribeDirectConnectGatewayAttachmentsResult,
+    __MetadataBearer {}
+
+/**
+ * <p>Lists the attachments between your Direct Connect gateways and virtual interfaces. You must specify
+ *       a Direct Connect gateway, a virtual interface, or both. If you specify a Direct Connect gateway, the response contains
+ *       all virtual interfaces attached to the Direct Connect gateway. If you specify a virtual interface, the
+ *       response contains all Direct Connect gateways attached to the virtual interface. If you specify both,
+ *       the response contains the attachment between the Direct Connect gateway and the virtual interface.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, DescribeDirectConnectGatewayAttachmentsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, DescribeDirectConnectGatewayAttachmentsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new DescribeDirectConnectGatewayAttachmentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeDirectConnectGatewayAttachmentsCommandInput} for command's `input` shape.
+ * @see {@link DescribeDirectConnectGatewayAttachmentsCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DescribeDirectConnectGatewayAttachmentsCommand extends $Command<
+  DescribeDirectConnectGatewayAttachmentsCommandInput,
+  DescribeDirectConnectGatewayAttachmentsCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DescribeDirectConnectGatewayAttachmentsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<
+    DescribeDirectConnectGatewayAttachmentsCommandInput,
+    DescribeDirectConnectGatewayAttachmentsCommandOutput
+  > {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "DescribeDirectConnectGatewayAttachmentsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DescribeDirectConnectGatewayAttachmentsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: DescribeDirectConnectGatewayAttachmentsResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(
+    input: DescribeDirectConnectGatewayAttachmentsCommandInput,
+    context: __SerdeContext
+  ): Promise<__HttpRequest> {
+    return serializeAws_json1_1DescribeDirectConnectGatewayAttachmentsCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<DescribeDirectConnectGatewayAttachmentsCommandOutput> {
+    return deserializeAws_json1_1DescribeDirectConnectGatewayAttachmentsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DescribeDirectConnectGatewaysCommand.ts

@@ -0,0 +1,100 @@
+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 { DescribeDirectConnectGatewaysRequest, DescribeDirectConnectGatewaysResult } from "../models/models_0";
+import {
+  deserializeAws_json1_1DescribeDirectConnectGatewaysCommand,
+  serializeAws_json1_1DescribeDirectConnectGatewaysCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DescribeDirectConnectGatewaysCommandInput extends DescribeDirectConnectGatewaysRequest {}
+export interface DescribeDirectConnectGatewaysCommandOutput
+  extends DescribeDirectConnectGatewaysResult,
+    __MetadataBearer {}
+
+/**
+ * <p>Lists all your Direct Connect gateways or only the specified Direct Connect gateway. Deleted Direct Connect gateways are not returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, DescribeDirectConnectGatewaysCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, DescribeDirectConnectGatewaysCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new DescribeDirectConnectGatewaysCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeDirectConnectGatewaysCommandInput} for command's `input` shape.
+ * @see {@link DescribeDirectConnectGatewaysCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DescribeDirectConnectGatewaysCommand extends $Command<
+  DescribeDirectConnectGatewaysCommandInput,
+  DescribeDirectConnectGatewaysCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DescribeDirectConnectGatewaysCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DescribeDirectConnectGatewaysCommandInput, DescribeDirectConnectGatewaysCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "DescribeDirectConnectGatewaysCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DescribeDirectConnectGatewaysRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: DescribeDirectConnectGatewaysResult.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: DescribeDirectConnectGatewaysCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DescribeDirectConnectGatewaysCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<DescribeDirectConnectGatewaysCommandOutput> {
+    return deserializeAws_json1_1DescribeDirectConnectGatewaysCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DescribeHostedConnectionsCommand.ts

@@ -0,0 +1,102 @@
+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 { Connections, DescribeHostedConnectionsRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1DescribeHostedConnectionsCommand,
+  serializeAws_json1_1DescribeHostedConnectionsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DescribeHostedConnectionsCommandInput extends DescribeHostedConnectionsRequest {}
+export interface DescribeHostedConnectionsCommandOutput extends Connections, __MetadataBearer {}
+
+/**
+ * <p>Lists the hosted connections that have been provisioned on the specified
+ *       interconnect or link aggregation group (LAG).</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, DescribeHostedConnectionsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, DescribeHostedConnectionsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new DescribeHostedConnectionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeHostedConnectionsCommandInput} for command's `input` shape.
+ * @see {@link DescribeHostedConnectionsCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DescribeHostedConnectionsCommand extends $Command<
+  DescribeHostedConnectionsCommandInput,
+  DescribeHostedConnectionsCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DescribeHostedConnectionsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DescribeHostedConnectionsCommandInput, DescribeHostedConnectionsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "DescribeHostedConnectionsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DescribeHostedConnectionsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: Connections.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: DescribeHostedConnectionsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DescribeHostedConnectionsCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<DescribeHostedConnectionsCommandOutput> {
+    return deserializeAws_json1_1DescribeHostedConnectionsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DescribeInterconnectLoaCommand.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 { DescribeInterconnectLoaRequest, DescribeInterconnectLoaResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1DescribeInterconnectLoaCommand,
+  serializeAws_json1_1DescribeInterconnectLoaCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DescribeInterconnectLoaCommandInput extends DescribeInterconnectLoaRequest {}
+export interface DescribeInterconnectLoaCommandOutput extends DescribeInterconnectLoaResponse, __MetadataBearer {}
+
+/**
+ * @deprecated
+ *
+ * <p>Deprecated. Use <a>DescribeLoa</a> instead.</p>
+ *          <p>Gets the LOA-CFA for the specified interconnect.</p>
+ *          <p>The Letter of Authorization - Connecting Facility Assignment (LOA-CFA) is a document that is used when establishing your cross connect to Amazon Web Services at the colocation facility.
+ *       For more information, see <a href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/Colocation.html">Requesting Cross Connects at Direct Connect Locations</a>
+ *       in the <i>Direct Connect User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, DescribeInterconnectLoaCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, DescribeInterconnectLoaCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new DescribeInterconnectLoaCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeInterconnectLoaCommandInput} for command's `input` shape.
+ * @see {@link DescribeInterconnectLoaCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DescribeInterconnectLoaCommand extends $Command<
+  DescribeInterconnectLoaCommandInput,
+  DescribeInterconnectLoaCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DescribeInterconnectLoaCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DescribeInterconnectLoaCommandInput, DescribeInterconnectLoaCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "DescribeInterconnectLoaCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DescribeInterconnectLoaRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: DescribeInterconnectLoaResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: DescribeInterconnectLoaCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DescribeInterconnectLoaCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DescribeInterconnectLoaCommandOutput> {
+    return deserializeAws_json1_1DescribeInterconnectLoaCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DescribeInterconnectsCommand.ts

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

package/src/commands/DescribeLagsCommand.ts

@@ -0,0 +1,95 @@
+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 { DescribeLagsRequest, Lags } from "../models/models_0";
+import {
+  deserializeAws_json1_1DescribeLagsCommand,
+  serializeAws_json1_1DescribeLagsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DescribeLagsCommandInput extends DescribeLagsRequest {}
+export interface DescribeLagsCommandOutput extends Lags, __MetadataBearer {}
+
+/**
+ * <p>Describes all your link aggregation groups (LAG) or the specified LAG.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, DescribeLagsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, DescribeLagsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new DescribeLagsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeLagsCommandInput} for command's `input` shape.
+ * @see {@link DescribeLagsCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DescribeLagsCommand extends $Command<
+  DescribeLagsCommandInput,
+  DescribeLagsCommandOutput,
+  DirectConnectClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DescribeLagsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DirectConnectClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DescribeLagsCommandInput, DescribeLagsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DirectConnectClient";
+    const commandName = "DescribeLagsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DescribeLagsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: Lags.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: DescribeLagsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DescribeLagsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DescribeLagsCommandOutput> {
+    return deserializeAws_json1_1DescribeLagsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}