@aws-sdk/client-mgn 3.216.0 → 3.218.0

package/dist-es/commands/CreateWaveCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateWaveRequestFilterSensitiveLog, WaveFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateWaveCommand, serializeAws_restJson1CreateWaveCommand, } from "../protocols/Aws_restJson1";
+export class CreateWaveCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateWaveCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "CreateWaveCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateWaveRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: WaveFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateWaveCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateWaveCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteApplicationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteApplicationRequestFilterSensitiveLog, DeleteApplicationResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteApplicationCommand, serializeAws_restJson1DeleteApplicationCommand, } from "../protocols/Aws_restJson1";
+export class DeleteApplicationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteApplicationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "DeleteApplicationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteApplicationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteApplicationResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteApplicationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteApplicationCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteWaveCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteWaveRequestFilterSensitiveLog, DeleteWaveResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteWaveCommand, serializeAws_restJson1DeleteWaveCommand, } from "../protocols/Aws_restJson1";
+export class DeleteWaveCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteWaveCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "DeleteWaveCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteWaveRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteWaveResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteWaveCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteWaveCommand(output, context);
+    }
+}

package/dist-es/commands/DisassociateApplicationsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DisassociateApplicationsRequestFilterSensitiveLog, DisassociateApplicationsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateApplicationsCommand, serializeAws_restJson1DisassociateApplicationsCommand, } from "../protocols/Aws_restJson1";
+export class DisassociateApplicationsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DisassociateApplicationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "DisassociateApplicationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DisassociateApplicationsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateApplicationsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DisassociateApplicationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DisassociateApplicationsCommand(output, context);
+    }
+}

package/dist-es/commands/DisassociateSourceServersCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DisassociateSourceServersRequestFilterSensitiveLog, DisassociateSourceServersResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateSourceServersCommand, serializeAws_restJson1DisassociateSourceServersCommand, } from "../protocols/Aws_restJson1";
+export class DisassociateSourceServersCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DisassociateSourceServersCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "DisassociateSourceServersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DisassociateSourceServersRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateSourceServersResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DisassociateSourceServersCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DisassociateSourceServersCommand(output, context);
+    }
+}

package/dist-es/commands/ListApplicationsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListApplicationsRequestFilterSensitiveLog, ListApplicationsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListApplicationsCommand, serializeAws_restJson1ListApplicationsCommand, } from "../protocols/Aws_restJson1";
+export class ListApplicationsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListApplicationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListApplicationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListApplicationsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListApplicationsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListApplicationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListApplicationsCommand(output, context);
+    }
+}

package/dist-es/commands/ListSourceServerActionsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListSourceServerActionsRequestFilterSensitiveLog, ListSourceServerActionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListSourceServerActionsCommand, serializeAws_restJson1ListSourceServerActionsCommand, } from "../protocols/Aws_restJson1";
+export class ListSourceServerActionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListSourceServerActionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListSourceServerActionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSourceServerActionsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSourceServerActionsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListSourceServerActionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListSourceServerActionsCommand(output, context);
+    }
+}

package/dist-es/commands/ListTemplateActionsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListTemplateActionsRequestFilterSensitiveLog, ListTemplateActionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListTemplateActionsCommand, serializeAws_restJson1ListTemplateActionsCommand, } from "../protocols/Aws_restJson1";
+export class ListTemplateActionsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListTemplateActionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListTemplateActionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListTemplateActionsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListTemplateActionsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListTemplateActionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListTemplateActionsCommand(output, context);
+    }
+}

package/dist-es/commands/ListWavesCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListWavesRequestFilterSensitiveLog, ListWavesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListWavesCommand, serializeAws_restJson1ListWavesCommand, } from "../protocols/Aws_restJson1";
+export class ListWavesCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListWavesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "ListWavesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListWavesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListWavesResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListWavesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListWavesCommand(output, context);
+    }
+}

package/dist-es/commands/PutSourceServerActionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutSourceServerActionRequestFilterSensitiveLog, SourceServerActionDocumentFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1PutSourceServerActionCommand, serializeAws_restJson1PutSourceServerActionCommand, } from "../protocols/Aws_restJson1";
+export class PutSourceServerActionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutSourceServerActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "PutSourceServerActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: PutSourceServerActionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: SourceServerActionDocumentFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1PutSourceServerActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1PutSourceServerActionCommand(output, context);
+    }
+}

package/dist-es/commands/PutTemplateActionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutTemplateActionRequestFilterSensitiveLog, TemplateActionDocumentFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1PutTemplateActionCommand, serializeAws_restJson1PutTemplateActionCommand, } from "../protocols/Aws_restJson1";
+export class PutTemplateActionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutTemplateActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "PutTemplateActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: PutTemplateActionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: TemplateActionDocumentFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1PutTemplateActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1PutTemplateActionCommand(output, context);
+    }
+}

package/dist-es/commands/RemoveSourceServerActionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { RemoveSourceServerActionRequestFilterSensitiveLog, RemoveSourceServerActionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1RemoveSourceServerActionCommand, serializeAws_restJson1RemoveSourceServerActionCommand, } from "../protocols/Aws_restJson1";
+export class RemoveSourceServerActionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, RemoveSourceServerActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "RemoveSourceServerActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: RemoveSourceServerActionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: RemoveSourceServerActionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1RemoveSourceServerActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1RemoveSourceServerActionCommand(output, context);
+    }
+}

package/dist-es/commands/RemoveTemplateActionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { RemoveTemplateActionRequestFilterSensitiveLog, RemoveTemplateActionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1RemoveTemplateActionCommand, serializeAws_restJson1RemoveTemplateActionCommand, } from "../protocols/Aws_restJson1";
+export class RemoveTemplateActionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, RemoveTemplateActionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "RemoveTemplateActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: RemoveTemplateActionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: RemoveTemplateActionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1RemoveTemplateActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1RemoveTemplateActionCommand(output, context);
+    }
+}

package/dist-es/commands/UnarchiveApplicationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ApplicationFilterSensitiveLog, UnarchiveApplicationRequestFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UnarchiveApplicationCommand, serializeAws_restJson1UnarchiveApplicationCommand, } from "../protocols/Aws_restJson1";
+export class UnarchiveApplicationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UnarchiveApplicationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "UnarchiveApplicationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UnarchiveApplicationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ApplicationFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UnarchiveApplicationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UnarchiveApplicationCommand(output, context);
+    }
+}

package/dist-es/commands/UnarchiveWaveCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UnarchiveWaveRequestFilterSensitiveLog, WaveFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UnarchiveWaveCommand, serializeAws_restJson1UnarchiveWaveCommand, } from "../protocols/Aws_restJson1";
+export class UnarchiveWaveCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UnarchiveWaveCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "MgnClient";
+        const commandName = "UnarchiveWaveCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UnarchiveWaveRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: WaveFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UnarchiveWaveCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UnarchiveWaveCommand(output, context);
+    }
+}