@aws-sdk/client-lightsail 3.35.0 → 3.38.0

package/src/commands/OpenInstancePublicPortsCommand.ts

@@ -1,99 +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 { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { OpenInstancePublicPortsRequest, OpenInstancePublicPortsResult } from "../models/models_1";
-import {
-  deserializeAws_json1_1OpenInstancePublicPortsCommand,
-  serializeAws_json1_1OpenInstancePublicPortsCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface OpenInstancePublicPortsCommandInput extends OpenInstancePublicPortsRequest {}
-export interface OpenInstancePublicPortsCommandOutput extends OpenInstancePublicPortsResult, __MetadataBearer {}
-
-/**
- * <p>Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses
- *       allowed to connect to the instance through the ports, and the protocol.</p>
- *          <p>The <code>OpenInstancePublicPorts</code> action supports tag-based access control via
- *       resource tags applied to the resource identified by <code>instanceName</code>. For more
- *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, OpenInstancePublicPortsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, OpenInstancePublicPortsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new OpenInstancePublicPortsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link OpenInstancePublicPortsCommandInput} for command's `input` shape.
- * @see {@link OpenInstancePublicPortsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class OpenInstancePublicPortsCommand extends $Command<
-  OpenInstancePublicPortsCommandInput,
-  OpenInstancePublicPortsCommandOutput,
-  LightsailClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: OpenInstancePublicPortsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LightsailClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<OpenInstancePublicPortsCommandInput, OpenInstancePublicPortsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LightsailClient";
-    const commandName = "OpenInstancePublicPortsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: OpenInstancePublicPortsRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: OpenInstancePublicPortsResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: OpenInstancePublicPortsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1OpenInstancePublicPortsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<OpenInstancePublicPortsCommandOutput> {
-    return deserializeAws_json1_1OpenInstancePublicPortsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/PeerVpcCommand.ts

@@ -1,88 +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 { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { PeerVpcRequest, PeerVpcResult } from "../models/models_1";
-import { deserializeAws_json1_1PeerVpcCommand, serializeAws_json1_1PeerVpcCommand } from "../protocols/Aws_json1_1";
-
-export interface PeerVpcCommandInput extends PeerVpcRequest {}
-export interface PeerVpcCommandOutput extends PeerVpcResult, __MetadataBearer {}
-
-/**
- * <p>Peers the Lightsail VPC with the user's default VPC.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, PeerVpcCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, PeerVpcCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new PeerVpcCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PeerVpcCommandInput} for command's `input` shape.
- * @see {@link PeerVpcCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PeerVpcCommand extends $Command<PeerVpcCommandInput, PeerVpcCommandOutput, LightsailClientResolvedConfig> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PeerVpcCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LightsailClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PeerVpcCommandInput, PeerVpcCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LightsailClient";
-    const commandName = "PeerVpcCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PeerVpcRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PeerVpcResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PeerVpcCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PeerVpcCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PeerVpcCommandOutput> {
-    return deserializeAws_json1_1PeerVpcCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/PutAlarmCommand.ts

@@ -1,102 +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 { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { PutAlarmRequest, PutAlarmResult } from "../models/models_1";
-import { deserializeAws_json1_1PutAlarmCommand, serializeAws_json1_1PutAlarmCommand } from "../protocols/Aws_json1_1";
-
-export interface PutAlarmCommandInput extends PutAlarmRequest {}
-export interface PutAlarmCommandOutput extends PutAlarmResult, __MetadataBearer {}
-
-/**
- * <p>Creates or updates an alarm, and associates it with the specified metric.</p>
- *          <p>An alarm is used to monitor a single metric for one of your resources. When a metric
- *       condition is met, the alarm can notify you by email, SMS text message, and a banner displayed
- *       on the Amazon Lightsail console. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms">Alarms
- *         in Amazon Lightsail</a>.</p>
- *          <p>When this action creates an alarm, the alarm state is immediately set to
- *         <code>INSUFFICIENT_DATA</code>. The alarm is then evaluated and its state is set
- *       appropriately. Any actions associated with the new state are then executed.</p>
- *          <p>When you update an existing alarm, its state is left unchanged, but the update completely
- *       overwrites the previous configuration of the alarm. The alarm is then evaluated with the
- *       updated configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, PutAlarmCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, PutAlarmCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new PutAlarmCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAlarmCommandInput} for command's `input` shape.
- * @see {@link PutAlarmCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutAlarmCommand extends $Command<
-  PutAlarmCommandInput,
-  PutAlarmCommandOutput,
-  LightsailClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutAlarmCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LightsailClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutAlarmCommandInput, PutAlarmCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LightsailClient";
-    const commandName = "PutAlarmCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutAlarmRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutAlarmResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutAlarmCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutAlarmCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutAlarmCommandOutput> {
-    return deserializeAws_json1_1PutAlarmCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/PutInstancePublicPortsCommand.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 { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { PutInstancePublicPortsRequest, PutInstancePublicPortsResult } from "../models/models_1";
-import {
-  deserializeAws_json1_1PutInstancePublicPortsCommand,
-  serializeAws_json1_1PutInstancePublicPortsCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface PutInstancePublicPortsCommandInput extends PutInstancePublicPortsRequest {}
-export interface PutInstancePublicPortsCommandOutput extends PutInstancePublicPortsResult, __MetadataBearer {}
-
-/**
- * <p>Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses
- *       allowed to connect to the instance through the ports, and the protocol. This action also
- *       closes all currently open ports that are not included in the request. Include all of the ports
- *       and the protocols you want to open in your <code>PutInstancePublicPorts</code>request. Or use
- *       the <code>OpenInstancePublicPorts</code> action to open ports without closing currently open
- *       ports.</p>
- *          <p>The <code>PutInstancePublicPorts</code> action supports tag-based access control via
- *       resource tags applied to the resource identified by <code>instanceName</code>. For more
- *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, PutInstancePublicPortsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, PutInstancePublicPortsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new PutInstancePublicPortsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutInstancePublicPortsCommandInput} for command's `input` shape.
- * @see {@link PutInstancePublicPortsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutInstancePublicPortsCommand extends $Command<
-  PutInstancePublicPortsCommandInput,
-  PutInstancePublicPortsCommandOutput,
-  LightsailClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutInstancePublicPortsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LightsailClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutInstancePublicPortsCommandInput, PutInstancePublicPortsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LightsailClient";
-    const commandName = "PutInstancePublicPortsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutInstancePublicPortsRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutInstancePublicPortsResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutInstancePublicPortsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutInstancePublicPortsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutInstancePublicPortsCommandOutput> {
-    return deserializeAws_json1_1PutInstancePublicPortsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/RebootInstanceCommand.ts

@@ -1,98 +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 { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { RebootInstanceRequest, RebootInstanceResult } from "../models/models_1";
-import {
-  deserializeAws_json1_1RebootInstanceCommand,
-  serializeAws_json1_1RebootInstanceCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface RebootInstanceCommandInput extends RebootInstanceRequest {}
-export interface RebootInstanceCommandOutput extends RebootInstanceResult, __MetadataBearer {}
-
-/**
- * <p>Restarts a specific instance.</p>
- *          <p>The <code>reboot instance</code> operation supports tag-based access control via resource
- *       tags applied to the resource identified by <code>instance name</code>. For more information,
- *       see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, RebootInstanceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, RebootInstanceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new RebootInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RebootInstanceCommandInput} for command's `input` shape.
- * @see {@link RebootInstanceCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class RebootInstanceCommand extends $Command<
-  RebootInstanceCommandInput,
-  RebootInstanceCommandOutput,
-  LightsailClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: RebootInstanceCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LightsailClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<RebootInstanceCommandInput, RebootInstanceCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LightsailClient";
-    const commandName = "RebootInstanceCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: RebootInstanceRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: RebootInstanceResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: RebootInstanceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1RebootInstanceCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<RebootInstanceCommandOutput> {
-    return deserializeAws_json1_1RebootInstanceCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/RebootRelationalDatabaseCommand.ts

@@ -1,98 +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 { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { RebootRelationalDatabaseRequest, RebootRelationalDatabaseResult } from "../models/models_1";
-import {
-  deserializeAws_json1_1RebootRelationalDatabaseCommand,
-  serializeAws_json1_1RebootRelationalDatabaseCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface RebootRelationalDatabaseCommandInput extends RebootRelationalDatabaseRequest {}
-export interface RebootRelationalDatabaseCommandOutput extends RebootRelationalDatabaseResult, __MetadataBearer {}
-
-/**
- * <p>Restarts a specific database in Amazon Lightsail.</p>
- *          <p>The <code>reboot relational database</code> operation supports tag-based access control
- *       via resource tags applied to the resource identified by relationalDatabaseName. For more
- *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, RebootRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, RebootRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new RebootRelationalDatabaseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RebootRelationalDatabaseCommandInput} for command's `input` shape.
- * @see {@link RebootRelationalDatabaseCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class RebootRelationalDatabaseCommand extends $Command<
-  RebootRelationalDatabaseCommandInput,
-  RebootRelationalDatabaseCommandOutput,
-  LightsailClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: RebootRelationalDatabaseCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LightsailClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<RebootRelationalDatabaseCommandInput, RebootRelationalDatabaseCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "LightsailClient";
-    const commandName = "RebootRelationalDatabaseCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: RebootRelationalDatabaseRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: RebootRelationalDatabaseResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: RebootRelationalDatabaseCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1RebootRelationalDatabaseCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<RebootRelationalDatabaseCommandOutput> {
-    return deserializeAws_json1_1RebootRelationalDatabaseCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}