@aws-sdk/client-lightsail 3.296.0 → 3.298.0

package/dist-types/commands/CreateCloudFormationStackCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateCloudFormationStackRequest, CreateCloudFormationStackResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateCloudFormationStackCommand}.
  */
 export interface CreateCloudFormationStackCommandInput extends CreateCloudFormationStackRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateCloudFormationStackCommand}.
  */
 export interface CreateCloudFormationStackCommandOutput extends CreateCloudFormationStackResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an AWS CloudFormation stack, which creates a new Amazon EC2 instance from an exported
  *       Amazon Lightsail snapshot. This operation results in a CloudFormation stack record that can be
  *       used to track the AWS CloudFormation stack created. Use the <code>get cloud formation stack
@@ -32,6 +37,8 @@ export interface CreateCloudFormationStackCommandOutput extends CreateCloudForma
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateCloudFormationStackCommandInput - {@link CreateCloudFormationStackCommandInput}
+ * @returns {@link CreateCloudFormationStackCommandOutput}
  * @see {@link CreateCloudFormationStackCommandInput} for command's `input` shape.
  * @see {@link CreateCloudFormationStackCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -71,11 +78,20 @@ export interface CreateCloudFormationStackCommandOutput extends CreateCloudForma
 export declare class CreateCloudFormationStackCommand extends $Command<CreateCloudFormationStackCommandInput, CreateCloudFormationStackCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateCloudFormationStackCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateCloudFormationStackCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCloudFormationStackCommandInput, CreateCloudFormationStackCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateContactMethodCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateContactMethodRequest, CreateContactMethodResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateContactMethodCommand}.
  */
 export interface CreateContactMethodCommandInput extends CreateContactMethodRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateContactMethodCommand}.
  */
 export interface CreateContactMethodCommandOutput extends CreateContactMethodResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an email or SMS text message contact method.</p>
  *          <p>A contact method is used to send you notifications about your Amazon Lightsail resources.
  *       You can add one email address and one mobile phone number contact method in each Amazon Web Services Region. However, SMS text messaging is not supported in some Amazon Web Services
@@ -29,6 +34,8 @@ export interface CreateContactMethodCommandOutput extends CreateContactMethodRes
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateContactMethodCommandInput - {@link CreateContactMethodCommandInput}
+ * @returns {@link CreateContactMethodCommandOutput}
  * @see {@link CreateContactMethodCommandInput} for command's `input` shape.
  * @see {@link CreateContactMethodCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -64,11 +71,20 @@ export interface CreateContactMethodCommandOutput extends CreateContactMethodRes
 export declare class CreateContactMethodCommand extends $Command<CreateContactMethodCommandInput, CreateContactMethodCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateContactMethodCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateContactMethodCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContactMethodCommandInput, CreateContactMethodCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateContainerServiceCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateContainerServiceRequest, CreateContainerServiceResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateContainerServiceCommand}.
  */
 export interface CreateContainerServiceCommandInput extends CreateContainerServiceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateContainerServiceCommand}.
  */
 export interface CreateContainerServiceCommandOutput extends CreateContainerServiceResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an Amazon Lightsail container service.</p>
  *          <p>A Lightsail container service is a compute resource to which you can deploy containers.
  *       For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-container-services">Container services in Amazon Lightsail</a> in the <i>Lightsail Dev
@@ -28,6 +33,8 @@ export interface CreateContainerServiceCommandOutput extends CreateContainerServ
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateContainerServiceCommandInput - {@link CreateContainerServiceCommandInput}
+ * @returns {@link CreateContainerServiceCommandOutput}
  * @see {@link CreateContainerServiceCommandInput} for command's `input` shape.
  * @see {@link CreateContainerServiceCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -60,11 +67,20 @@ export interface CreateContainerServiceCommandOutput extends CreateContainerServ
 export declare class CreateContainerServiceCommand extends $Command<CreateContainerServiceCommandInput, CreateContainerServiceCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateContainerServiceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateContainerServiceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContainerServiceCommandInput, CreateContainerServiceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateContainerServiceDeploymentCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateContainerServiceDeploymentRequest, CreateContainerServiceDeploymentResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateContainerServiceDeploymentCommand}.
  */
 export interface CreateContainerServiceDeploymentCommandInput extends CreateContainerServiceDeploymentRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateContainerServiceDeploymentCommand}.
  */
 export interface CreateContainerServiceDeploymentCommandOutput extends CreateContainerServiceDeploymentResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a deployment for your Amazon Lightsail container service.</p>
  *          <p>A deployment specifies the containers that will be launched on the container service and
  *       their settings, such as the ports to open, the environment variables to apply, and the launch
@@ -34,6 +39,8 @@ export interface CreateContainerServiceDeploymentCommandOutput extends CreateCon
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateContainerServiceDeploymentCommandInput - {@link CreateContainerServiceDeploymentCommandInput}
+ * @returns {@link CreateContainerServiceDeploymentCommandOutput}
  * @see {@link CreateContainerServiceDeploymentCommandInput} for command's `input` shape.
  * @see {@link CreateContainerServiceDeploymentCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -66,11 +73,20 @@ export interface CreateContainerServiceDeploymentCommandOutput extends CreateCon
 export declare class CreateContainerServiceDeploymentCommand extends $Command<CreateContainerServiceDeploymentCommandInput, CreateContainerServiceDeploymentCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateContainerServiceDeploymentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateContainerServiceDeploymentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContainerServiceDeploymentCommandInput, CreateContainerServiceDeploymentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateContainerServiceRegistryLoginCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateContainerServiceRegistryLoginRequest, CreateContainerServiceRegistryLoginResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateContainerServiceRegistryLoginCommand}.
  */
 export interface CreateContainerServiceRegistryLoginCommandInput extends CreateContainerServiceRegistryLoginRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateContainerServiceRegistryLoginCommand}.
  */
 export interface CreateContainerServiceRegistryLoginCommandOutput extends CreateContainerServiceRegistryLoginResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a temporary set of log in credentials that you can use to log in to the Docker
  *       process on your local machine. After you're logged in, you can use the native Docker commands
  *       to push your local container images to the container image registry of your Amazon Lightsail
@@ -44,6 +49,8 @@ export interface CreateContainerServiceRegistryLoginCommandOutput extends Create
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateContainerServiceRegistryLoginCommandInput - {@link CreateContainerServiceRegistryLoginCommandInput}
+ * @returns {@link CreateContainerServiceRegistryLoginCommandOutput}
  * @see {@link CreateContainerServiceRegistryLoginCommandInput} for command's `input` shape.
  * @see {@link CreateContainerServiceRegistryLoginCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -76,11 +83,20 @@ export interface CreateContainerServiceRegistryLoginCommandOutput extends Create
 export declare class CreateContainerServiceRegistryLoginCommand extends $Command<CreateContainerServiceRegistryLoginCommandInput, CreateContainerServiceRegistryLoginCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateContainerServiceRegistryLoginCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateContainerServiceRegistryLoginCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContainerServiceRegistryLoginCommandInput, CreateContainerServiceRegistryLoginCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateDiskCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateDiskRequest, CreateDiskResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDiskCommand}.
  */
 export interface CreateDiskCommandInput extends CreateDiskRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDiskCommand}.
  */
 export interface CreateDiskCommandOutput extends CreateDiskResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a block storage disk that can be attached to an Amazon Lightsail instance in the
  *       same Availability Zone (e.g., <code>us-east-2a</code>).</p>
  *          <p>The <code>create disk</code> operation supports tag-based access control via request tags.
@@ -28,6 +33,8 @@ export interface CreateDiskCommandOutput extends CreateDiskResult, __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDiskCommandInput - {@link CreateDiskCommandInput}
+ * @returns {@link CreateDiskCommandOutput}
  * @see {@link CreateDiskCommandInput} for command's `input` shape.
  * @see {@link CreateDiskCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -67,11 +74,20 @@ export interface CreateDiskCommandOutput extends CreateDiskResult, __MetadataBea
 export declare class CreateDiskCommand extends $Command<CreateDiskCommandInput, CreateDiskCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateDiskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDiskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDiskCommandInput, CreateDiskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateDiskFromSnapshotCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateDiskFromSnapshotRequest, CreateDiskFromSnapshotResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDiskFromSnapshotCommand}.
  */
 export interface CreateDiskFromSnapshotCommandInput extends CreateDiskFromSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDiskFromSnapshotCommand}.
  */
 export interface CreateDiskFromSnapshotCommandOutput extends CreateDiskFromSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a block storage disk from a manual or automatic snapshot of a disk. The resulting
  *       disk can be attached to an Amazon Lightsail instance in the same Availability Zone (e.g.,
  *         <code>us-east-2a</code>).</p>
@@ -30,6 +35,8 @@ export interface CreateDiskFromSnapshotCommandOutput extends CreateDiskFromSnaps
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDiskFromSnapshotCommandInput - {@link CreateDiskFromSnapshotCommandInput}
+ * @returns {@link CreateDiskFromSnapshotCommandOutput}
  * @see {@link CreateDiskFromSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateDiskFromSnapshotCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -69,11 +76,20 @@ export interface CreateDiskFromSnapshotCommandOutput extends CreateDiskFromSnaps
 export declare class CreateDiskFromSnapshotCommand extends $Command<CreateDiskFromSnapshotCommandInput, CreateDiskFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateDiskFromSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDiskFromSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDiskFromSnapshotCommandInput, CreateDiskFromSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateDiskSnapshotCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateDiskSnapshotRequest, CreateDiskSnapshotResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDiskSnapshotCommand}.
  */
 export interface CreateDiskSnapshotCommandInput extends CreateDiskSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDiskSnapshotCommand}.
  */
 export interface CreateDiskSnapshotCommandOutput extends CreateDiskSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a snapshot of a block storage disk. You can use snapshots for backups, to make
  *       copies of disks, and to save data before shutting down a Lightsail instance.</p>
  *          <p>You can take a snapshot of an attached disk that is in use; however, snapshots only
@@ -43,6 +48,8 @@ export interface CreateDiskSnapshotCommandOutput extends CreateDiskSnapshotResul
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDiskSnapshotCommandInput - {@link CreateDiskSnapshotCommandInput}
+ * @returns {@link CreateDiskSnapshotCommandOutput}
  * @see {@link CreateDiskSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateDiskSnapshotCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -82,11 +89,20 @@ export interface CreateDiskSnapshotCommandOutput extends CreateDiskSnapshotResul
 export declare class CreateDiskSnapshotCommand extends $Command<CreateDiskSnapshotCommandInput, CreateDiskSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateDiskSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDiskSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDiskSnapshotCommandInput, CreateDiskSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateDistributionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateDistributionRequest, CreateDistributionResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDistributionCommand}.
  */
 export interface CreateDistributionCommandInput extends CreateDistributionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDistributionCommand}.
  */
 export interface CreateDistributionCommandOutput extends CreateDistributionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an Amazon Lightsail content delivery network (CDN) distribution.</p>
  *          <p>A distribution is a globally distributed network of caching servers that improve the
  *       performance of your website or web application hosted on a Lightsail instance. For more
@@ -28,6 +33,8 @@ export interface CreateDistributionCommandOutput extends CreateDistributionResul
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDistributionCommandInput - {@link CreateDistributionCommandInput}
+ * @returns {@link CreateDistributionCommandOutput}
  * @see {@link CreateDistributionCommandInput} for command's `input` shape.
  * @see {@link CreateDistributionCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -63,11 +70,20 @@ export interface CreateDistributionCommandOutput extends CreateDistributionResul
 export declare class CreateDistributionCommand extends $Command<CreateDistributionCommandInput, CreateDistributionCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateDistributionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDistributionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDistributionCommandInput, CreateDistributionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateDomainCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateDomainRequest, CreateDomainResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDomainCommand}.
  */
 export interface CreateDomainCommandInput extends CreateDomainRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDomainCommand}.
  */
 export interface CreateDomainCommandOutput extends CreateDomainResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a domain resource for the specified domain (e.g., example.com).</p>
  *          <p>The <code>create domain</code> operation supports tag-based access control via request
  *       tags. 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>
@@ -27,6 +32,8 @@ export interface CreateDomainCommandOutput extends CreateDomainResult, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDomainCommandInput - {@link CreateDomainCommandInput}
+ * @returns {@link CreateDomainCommandOutput}
  * @see {@link CreateDomainCommandInput} for command's `input` shape.
  * @see {@link CreateDomainCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -66,11 +73,20 @@ export interface CreateDomainCommandOutput extends CreateDomainResult, __Metadat
 export declare class CreateDomainCommand extends $Command<CreateDomainCommandInput, CreateDomainCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateDomainCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDomainCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDomainCommandInput, CreateDomainCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateDomainEntryCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateDomainEntryRequest, CreateDomainEntryResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDomainEntryCommand}.
  */
 export interface CreateDomainEntryCommandInput extends CreateDomainEntryRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDomainEntryCommand}.
  */
 export interface CreateDomainEntryCommandOutput extends CreateDomainEntryResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates one of the following domain name system (DNS) records in a domain DNS zone:
  *       Address (A), canonical name (CNAME), mail exchanger (MX), name server (NS), start of authority
  *       (SOA), service locator (SRV), or text (TXT).</p>
@@ -30,6 +35,8 @@ export interface CreateDomainEntryCommandOutput extends CreateDomainEntryResult,
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDomainEntryCommandInput - {@link CreateDomainEntryCommandInput}
+ * @returns {@link CreateDomainEntryCommandOutput}
  * @see {@link CreateDomainEntryCommandInput} for command's `input` shape.
  * @see {@link CreateDomainEntryCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -69,11 +76,20 @@ export interface CreateDomainEntryCommandOutput extends CreateDomainEntryResult,
 export declare class CreateDomainEntryCommand extends $Command<CreateDomainEntryCommandInput, CreateDomainEntryCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateDomainEntryCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDomainEntryCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDomainEntryCommandInput, CreateDomainEntryCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateGUISessionAccessDetailsCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateGUISessionAccessDetailsRequest, CreateGUISessionAccessDetailsResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateGUISessionAccessDetailsCommand}.
  */
 export interface CreateGUISessionAccessDetailsCommandInput extends CreateGUISessionAccessDetailsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateGUISessionAccessDetailsCommand}.
  */
 export interface CreateGUISessionAccessDetailsCommandOutput extends CreateGUISessionAccessDetailsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates two URLs that are used to access a virtual computer’s graphical user interface (GUI)
  *       session. The primary URL initiates a web-based NICE DCV session to the virtual computer's application. The secondary URL initiates a web-based NICE DCV session to the virtual computer's operating session. </p>
  *          <p>Use <code>StartGUISession</code> to open the session.</p>
@@ -27,6 +32,8 @@ export interface CreateGUISessionAccessDetailsCommandOutput extends CreateGUISes
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateGUISessionAccessDetailsCommandInput - {@link CreateGUISessionAccessDetailsCommandInput}
+ * @returns {@link CreateGUISessionAccessDetailsCommandOutput}
  * @see {@link CreateGUISessionAccessDetailsCommandInput} for command's `input` shape.
  * @see {@link CreateGUISessionAccessDetailsCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -59,11 +66,20 @@ export interface CreateGUISessionAccessDetailsCommandOutput extends CreateGUISes
 export declare class CreateGUISessionAccessDetailsCommand extends $Command<CreateGUISessionAccessDetailsCommandInput, CreateGUISessionAccessDetailsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateGUISessionAccessDetailsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateGUISessionAccessDetailsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGUISessionAccessDetailsCommandInput, CreateGUISessionAccessDetailsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }