@aws-sdk/client-mgn 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { MarkAsArchivedRequest, SourceServer } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link MarkAsArchivedCommand}.
  */
 export interface MarkAsArchivedCommandInput extends MarkAsArchivedRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link MarkAsArchivedCommand}.
  */
 export interface MarkAsArchivedCommandOutput extends SourceServer, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Archives specific Source Servers by setting the SourceServer.isArchived property to true for specified SourceServers by ID. This command only works for SourceServers with a lifecycle. state which equals DISCONNECTED or CUTOVER.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface MarkAsArchivedCommandOutput extends SourceServer, __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param MarkAsArchivedCommandInput - {@link MarkAsArchivedCommandInput}
+ * @returns {@link MarkAsArchivedCommandOutput}
  * @see {@link MarkAsArchivedCommandInput} for command's `input` shape.
  * @see {@link MarkAsArchivedCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -43,11 +50,20 @@ export interface MarkAsArchivedCommandOutput extends SourceServer, __MetadataBea
 export declare class MarkAsArchivedCommand extends $Command<MarkAsArchivedCommandInput, MarkAsArchivedCommandOutput, MgnClientResolvedConfig> {
     readonly input: MarkAsArchivedCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: MarkAsArchivedCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<MarkAsArchivedCommandInput, MarkAsArchivedCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { PutSourceServerActionRequest, SourceServerActionDocument } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link PutSourceServerActionCommand}.
  */
 export interface PutSourceServerActionCommandInput extends PutSourceServerActionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutSourceServerActionCommand}.
  */
 export interface PutSourceServerActionCommandOutput extends SourceServerActionDocument, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Put source server post migration custom action.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface PutSourceServerActionCommandOutput extends SourceServerActionDo
  * const response = await client.send(command);
  * ```
  *
+ * @param PutSourceServerActionCommandInput - {@link PutSourceServerActionCommandInput}
+ * @returns {@link PutSourceServerActionCommandOutput}
  * @see {@link PutSourceServerActionCommandInput} for command's `input` shape.
  * @see {@link PutSourceServerActionCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -46,11 +53,20 @@ export interface PutSourceServerActionCommandOutput extends SourceServerActionDo
 export declare class PutSourceServerActionCommand extends $Command<PutSourceServerActionCommandInput, PutSourceServerActionCommandOutput, MgnClientResolvedConfig> {
     readonly input: PutSourceServerActionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutSourceServerActionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSourceServerActionCommandInput, PutSourceServerActionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { PutTemplateActionRequest, TemplateActionDocument } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link PutTemplateActionCommand}.
  */
 export interface PutTemplateActionCommandInput extends PutTemplateActionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutTemplateActionCommand}.
  */
 export interface PutTemplateActionCommandOutput extends TemplateActionDocument, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Put template post migration custom action.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface PutTemplateActionCommandOutput extends TemplateActionDocument,
  * const response = await client.send(command);
  * ```
  *
+ * @param PutTemplateActionCommandInput - {@link PutTemplateActionCommandInput}
+ * @returns {@link PutTemplateActionCommandOutput}
  * @see {@link PutTemplateActionCommandInput} for command's `input` shape.
  * @see {@link PutTemplateActionCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -46,11 +53,20 @@ export interface PutTemplateActionCommandOutput extends TemplateActionDocument,
 export declare class PutTemplateActionCommand extends $Command<PutTemplateActionCommandInput, PutTemplateActionCommandOutput, MgnClientResolvedConfig> {
     readonly input: PutTemplateActionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutTemplateActionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutTemplateActionCommandInput, PutTemplateActionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { RemoveSourceServerActionRequest, RemoveSourceServerActionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link RemoveSourceServerActionCommand}.
  */
 export interface RemoveSourceServerActionCommandInput extends RemoveSourceServerActionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RemoveSourceServerActionCommand}.
  */
 export interface RemoveSourceServerActionCommandOutput extends RemoveSourceServerActionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Remove source server post migration custom action.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface RemoveSourceServerActionCommandOutput extends RemoveSourceServe
  * const response = await client.send(command);
  * ```
  *
+ * @param RemoveSourceServerActionCommandInput - {@link RemoveSourceServerActionCommandInput}
+ * @returns {@link RemoveSourceServerActionCommandOutput}
  * @see {@link RemoveSourceServerActionCommandInput} for command's `input` shape.
  * @see {@link RemoveSourceServerActionCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -43,11 +50,20 @@ export interface RemoveSourceServerActionCommandOutput extends RemoveSourceServe
 export declare class RemoveSourceServerActionCommand extends $Command<RemoveSourceServerActionCommandInput, RemoveSourceServerActionCommandOutput, MgnClientResolvedConfig> {
     readonly input: RemoveSourceServerActionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RemoveSourceServerActionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveSourceServerActionCommandInput, RemoveSourceServerActionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { RemoveTemplateActionRequest, RemoveTemplateActionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link RemoveTemplateActionCommand}.
  */
 export interface RemoveTemplateActionCommandInput extends RemoveTemplateActionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RemoveTemplateActionCommand}.
  */
 export interface RemoveTemplateActionCommandOutput extends RemoveTemplateActionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Remove template post migration custom action.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface RemoveTemplateActionCommandOutput extends RemoveTemplateActionR
  * const response = await client.send(command);
  * ```
  *
+ * @param RemoveTemplateActionCommandInput - {@link RemoveTemplateActionCommandInput}
+ * @returns {@link RemoveTemplateActionCommandOutput}
  * @see {@link RemoveTemplateActionCommandInput} for command's `input` shape.
  * @see {@link RemoveTemplateActionCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -43,11 +50,20 @@ export interface RemoveTemplateActionCommandOutput extends RemoveTemplateActionR
 export declare class RemoveTemplateActionCommand extends $Command<RemoveTemplateActionCommandInput, RemoveTemplateActionCommandOutput, MgnClientResolvedConfig> {
     readonly input: RemoveTemplateActionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RemoveTemplateActionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTemplateActionCommandInput, RemoveTemplateActionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { RetryDataReplicationRequest, SourceServer } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link RetryDataReplicationCommand}.
  */
 export interface RetryDataReplicationCommandInput extends RetryDataReplicationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RetryDataReplicationCommand}.
  */
 export interface RetryDataReplicationCommandOutput extends SourceServer, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Causes the data replication initiation sequence to begin immediately upon next Handshake for specified SourceServer IDs, regardless of when the previous initiation started. This command will not work if the SourceServer is not stalled or is in a DISCONNECTED or STOPPED state.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface RetryDataReplicationCommandOutput extends SourceServer, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param RetryDataReplicationCommandInput - {@link RetryDataReplicationCommandInput}
+ * @returns {@link RetryDataReplicationCommandOutput}
  * @see {@link RetryDataReplicationCommandInput} for command's `input` shape.
  * @see {@link RetryDataReplicationCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -43,11 +50,20 @@ export interface RetryDataReplicationCommandOutput extends SourceServer, __Metad
 export declare class RetryDataReplicationCommand extends $Command<RetryDataReplicationCommandInput, RetryDataReplicationCommandOutput, MgnClientResolvedConfig> {
     readonly input: RetryDataReplicationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RetryDataReplicationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RetryDataReplicationCommandInput, RetryDataReplicationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { StartCutoverRequest, StartCutoverResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StartCutoverCommand}.
  */
 export interface StartCutoverCommandInput extends StartCutoverRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartCutoverCommand}.
  */
 export interface StartCutoverCommandOutput extends StartCutoverResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Launches a Cutover Instance for specific Source Servers. This command starts a LAUNCH job whose initiatedBy property is StartCutover and changes the SourceServer.lifeCycle.state property to CUTTING_OVER.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface StartCutoverCommandOutput extends StartCutoverResponse, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param StartCutoverCommandInput - {@link StartCutoverCommandInput}
+ * @returns {@link StartCutoverCommandOutput}
  * @see {@link StartCutoverCommandInput} for command's `input` shape.
  * @see {@link StartCutoverCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -43,11 +50,20 @@ export interface StartCutoverCommandOutput extends StartCutoverResponse, __Metad
 export declare class StartCutoverCommand extends $Command<StartCutoverCommandInput, StartCutoverCommandOutput, MgnClientResolvedConfig> {
     readonly input: StartCutoverCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartCutoverCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartCutoverCommandInput, StartCutoverCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -0,0 +1,69 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
+import { StartExportRequest, StartExportResponse } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link StartExportCommand}.
+ */
+export interface StartExportCommandInput extends StartExportRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link StartExportCommand}.
+ */
+export interface StartExportCommandOutput extends StartExportResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Start export.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MgnClient, StartExportCommand } from "@aws-sdk/client-mgn"; // ES Modules import
+ * // const { MgnClient, StartExportCommand } = require("@aws-sdk/client-mgn"); // CommonJS import
+ * const client = new MgnClient(config);
+ * const command = new StartExportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param StartExportCommandInput - {@link StartExportCommandInput}
+ * @returns {@link StartExportCommandOutput}
+ * @see {@link StartExportCommandInput} for command's `input` shape.
+ * @see {@link StartExportCommandOutput} for command's `response` shape.
+ * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
+ *
+ * @throws {@link ServiceQuotaExceededException} (client fault)
+ *  <p>The request could not be completed because its exceeded the service quota.</p>
+ *
+ * @throws {@link UninitializedAccountException} (client fault)
+ *  <p>Uninitialized account exception.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>Validate exception.</p>
+ *
+ *
+ */
+export declare class StartExportCommand extends $Command<StartExportCommandInput, StartExportCommandOutput, MgnClientResolvedConfig> {
+    readonly input: StartExportCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: StartExportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartExportCommandInput, StartExportCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,75 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
+import { StartImportRequest, StartImportResponse } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link StartImportCommand}.
+ */
+export interface StartImportCommandInput extends StartImportRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link StartImportCommand}.
+ */
+export interface StartImportCommandOutput extends StartImportResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Start import.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MgnClient, StartImportCommand } from "@aws-sdk/client-mgn"; // ES Modules import
+ * // const { MgnClient, StartImportCommand } = require("@aws-sdk/client-mgn"); // CommonJS import
+ * const client = new MgnClient(config);
+ * const command = new StartImportCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param StartImportCommandInput - {@link StartImportCommandInput}
+ * @returns {@link StartImportCommandOutput}
+ * @see {@link StartImportCommandInput} for command's `input` shape.
+ * @see {@link StartImportCommandOutput} for command's `response` shape.
+ * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
+ *
+ * @throws {@link ConflictException} (client fault)
+ *  <p>The request could not be completed due to a conflict with the current state of the target resource.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>Resource not found exception.</p>
+ *
+ * @throws {@link ServiceQuotaExceededException} (client fault)
+ *  <p>The request could not be completed because its exceeded the service quota.</p>
+ *
+ * @throws {@link UninitializedAccountException} (client fault)
+ *  <p>Uninitialized account exception.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>Validate exception.</p>
+ *
+ *
+ */
+export declare class StartImportCommand extends $Command<StartImportCommandInput, StartImportCommandOutput, MgnClientResolvedConfig> {
+    readonly input: StartImportCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: StartImportCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartImportCommandInput, StartImportCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { SourceServer, StartReplicationRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StartReplicationCommand}.
  */
 export interface StartReplicationCommandInput extends StartReplicationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartReplicationCommand}.
  */
 export interface StartReplicationCommandOutput extends SourceServer, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Starts replication for SNAPSHOT_SHIPPING agents.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface StartReplicationCommandOutput extends SourceServer, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param StartReplicationCommandInput - {@link StartReplicationCommandInput}
+ * @returns {@link StartReplicationCommandOutput}
  * @see {@link StartReplicationCommandInput} for command's `input` shape.
  * @see {@link StartReplicationCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -49,11 +56,20 @@ export interface StartReplicationCommandOutput extends SourceServer, __MetadataB
 export declare class StartReplicationCommand extends $Command<StartReplicationCommandInput, StartReplicationCommandOutput, MgnClientResolvedConfig> {
     readonly input: StartReplicationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartReplicationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartReplicationCommandInput, StartReplicationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { StartTestRequest, StartTestResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StartTestCommand}.
  */
 export interface StartTestCommandInput extends StartTestRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartTestCommand}.
  */
 export interface StartTestCommandOutput extends StartTestResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Launches a Test Instance for specific Source Servers. This command starts a LAUNCH job whose initiatedBy property is StartTest and changes the SourceServer.lifeCycle.state property to TESTING.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface StartTestCommandOutput extends StartTestResponse, __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param StartTestCommandInput - {@link StartTestCommandInput}
+ * @returns {@link StartTestCommandOutput}
  * @see {@link StartTestCommandInput} for command's `input` shape.
  * @see {@link StartTestCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -43,11 +50,20 @@ export interface StartTestCommandOutput extends StartTestResponse, __MetadataBea
 export declare class StartTestCommand extends $Command<StartTestCommandInput, StartTestCommandOutput, MgnClientResolvedConfig> {
     readonly input: StartTestCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartTestCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartTestCommandInput, StartTestCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { MgnClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MgnClient";
 import { TagResourceRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link TagResourceCommand}.
  */
 export interface TagResourceCommandInput extends TagResourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link TagResourceCommand}.
  */
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds or overwrites only the specified tags for the specified Application Migration Service resource or resources. When you specify an existing tag key, the value is overwritten with the new value. Each resource can have a maximum of 50 tags. Each tag consists of a key and optional value.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface TagResourceCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param TagResourceCommandInput - {@link TagResourceCommandInput}
+ * @returns {@link TagResourceCommandOutput}
  * @see {@link TagResourceCommandInput} for command's `input` shape.
  * @see {@link TagResourceCommandOutput} for command's `response` shape.
  * @see {@link MgnClientResolvedConfig | config} for MgnClient's `config` shape.
@@ -49,11 +56,20 @@ export interface TagResourceCommandOutput extends __MetadataBearer {
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, MgnClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: TagResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MgnClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }