@aws-sdk/client-fis 3.183.0 → 3.185.0

package/dist-es/commands/GetExperimentCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetExperimentRequestFilterSensitiveLog, GetExperimentResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetExperimentCommand, serializeAws_restJson1GetExperimentCommand, } from "../protocols/Aws_restJson1";
-export class GetExperimentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetExperimentCommand = (function (_super) {
+    __extends(GetExperimentCommand, _super);
+    function GetExperimentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetExperimentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "GetExperimentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "GetExperimentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetExperimentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetExperimentResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetExperimentCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetExperimentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetExperimentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetExperimentCommand(output, context);
-    }
-}
+    };
+    return GetExperimentCommand;
+}($Command));
+export { GetExperimentCommand };

package/dist-es/commands/GetExperimentTemplateCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetExperimentTemplateRequestFilterSensitiveLog, GetExperimentTemplateResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetExperimentTemplateCommand, serializeAws_restJson1GetExperimentTemplateCommand, } from "../protocols/Aws_restJson1";
-export class GetExperimentTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetExperimentTemplateCommand = (function (_super) {
+    __extends(GetExperimentTemplateCommand, _super);
+    function GetExperimentTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetExperimentTemplateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "GetExperimentTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "GetExperimentTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetExperimentTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetExperimentTemplateResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetExperimentTemplateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetExperimentTemplateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetExperimentTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetExperimentTemplateCommand(output, context);
-    }
-}
+    };
+    return GetExperimentTemplateCommand;
+}($Command));
+export { GetExperimentTemplateCommand };

package/dist-es/commands/GetTargetResourceTypeCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetTargetResourceTypeRequestFilterSensitiveLog, GetTargetResourceTypeResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetTargetResourceTypeCommand, serializeAws_restJson1GetTargetResourceTypeCommand, } from "../protocols/Aws_restJson1";
-export class GetTargetResourceTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetTargetResourceTypeCommand = (function (_super) {
+    __extends(GetTargetResourceTypeCommand, _super);
+    function GetTargetResourceTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetTargetResourceTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "GetTargetResourceTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "GetTargetResourceTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetTargetResourceTypeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetTargetResourceTypeResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetTargetResourceTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetTargetResourceTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetTargetResourceTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetTargetResourceTypeCommand(output, context);
-    }
-}
+    };
+    return GetTargetResourceTypeCommand;
+}($Command));
+export { GetTargetResourceTypeCommand };

package/dist-es/commands/ListActionsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListActionsRequestFilterSensitiveLog, ListActionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListActionsCommand, serializeAws_restJson1ListActionsCommand, } from "../protocols/Aws_restJson1";
-export class ListActionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListActionsCommand = (function (_super) {
+    __extends(ListActionsCommand, _super);
+    function ListActionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListActionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "ListActionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "ListActionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListActionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListActionsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListActionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListActionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListActionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListActionsCommand(output, context);
-    }
-}
+    };
+    return ListActionsCommand;
+}($Command));
+export { ListActionsCommand };

package/dist-es/commands/ListExperimentTemplatesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListExperimentTemplatesRequestFilterSensitiveLog, ListExperimentTemplatesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListExperimentTemplatesCommand, serializeAws_restJson1ListExperimentTemplatesCommand, } from "../protocols/Aws_restJson1";
-export class ListExperimentTemplatesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListExperimentTemplatesCommand = (function (_super) {
+    __extends(ListExperimentTemplatesCommand, _super);
+    function ListExperimentTemplatesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListExperimentTemplatesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "ListExperimentTemplatesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "ListExperimentTemplatesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListExperimentTemplatesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListExperimentTemplatesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListExperimentTemplatesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListExperimentTemplatesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListExperimentTemplatesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListExperimentTemplatesCommand(output, context);
-    }
-}
+    };
+    return ListExperimentTemplatesCommand;
+}($Command));
+export { ListExperimentTemplatesCommand };

package/dist-es/commands/ListExperimentsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListExperimentsRequestFilterSensitiveLog, ListExperimentsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListExperimentsCommand, serializeAws_restJson1ListExperimentsCommand, } from "../protocols/Aws_restJson1";
-export class ListExperimentsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListExperimentsCommand = (function (_super) {
+    __extends(ListExperimentsCommand, _super);
+    function ListExperimentsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListExperimentsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "ListExperimentsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "ListExperimentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListExperimentsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListExperimentsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListExperimentsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListExperimentsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListExperimentsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListExperimentsCommand(output, context);
-    }
-}
+    };
+    return ListExperimentsCommand;
+}($Command));
+export { ListExperimentsCommand };

package/dist-es/commands/ListTagsForResourceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListTagsForResourceRequestFilterSensitiveLog, ListTagsForResourceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListTagsForResourceCommand, serializeAws_restJson1ListTagsForResourceCommand, } from "../protocols/Aws_restJson1";
-export class ListTagsForResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTagsForResourceCommand = (function (_super) {
+    __extends(ListTagsForResourceCommand, _super);
+    function ListTagsForResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTagsForResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "ListTagsForResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "ListTagsForResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListTagsForResourceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListTagsForResourceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListTagsForResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListTagsForResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListTagsForResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListTagsForResourceCommand(output, context);
-    }
-}
+    };
+    return ListTagsForResourceCommand;
+}($Command));
+export { ListTagsForResourceCommand };

package/dist-es/commands/ListTargetResourceTypesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListTargetResourceTypesRequestFilterSensitiveLog, ListTargetResourceTypesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListTargetResourceTypesCommand, serializeAws_restJson1ListTargetResourceTypesCommand, } from "../protocols/Aws_restJson1";
-export class ListTargetResourceTypesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTargetResourceTypesCommand = (function (_super) {
+    __extends(ListTargetResourceTypesCommand, _super);
+    function ListTargetResourceTypesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTargetResourceTypesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "ListTargetResourceTypesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "ListTargetResourceTypesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListTargetResourceTypesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListTargetResourceTypesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListTargetResourceTypesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListTargetResourceTypesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListTargetResourceTypesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListTargetResourceTypesCommand(output, context);
-    }
-}
+    };
+    return ListTargetResourceTypesCommand;
+}($Command));
+export { ListTargetResourceTypesCommand };

package/dist-es/commands/StartExperimentCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartExperimentRequestFilterSensitiveLog, StartExperimentResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1StartExperimentCommand, serializeAws_restJson1StartExperimentCommand, } from "../protocols/Aws_restJson1";
-export class StartExperimentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartExperimentCommand = (function (_super) {
+    __extends(StartExperimentCommand, _super);
+    function StartExperimentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartExperimentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "StartExperimentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "StartExperimentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartExperimentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartExperimentResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartExperimentCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StartExperimentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartExperimentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StartExperimentCommand(output, context);
-    }
-}
+    };
+    return StartExperimentCommand;
+}($Command));
+export { StartExperimentCommand };

package/dist-es/commands/StopExperimentCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StopExperimentRequestFilterSensitiveLog, StopExperimentResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1StopExperimentCommand, serializeAws_restJson1StopExperimentCommand, } from "../protocols/Aws_restJson1";
-export class StopExperimentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StopExperimentCommand = (function (_super) {
+    __extends(StopExperimentCommand, _super);
+    function StopExperimentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StopExperimentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FisClient";
-        const commandName = "StopExperimentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FisClient";
+        var commandName = "StopExperimentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StopExperimentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopExperimentResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopExperimentCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1StopExperimentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StopExperimentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1StopExperimentCommand(output, context);
-    }
-}
+    };
+    return StopExperimentCommand;
+}($Command));
+export { StopExperimentCommand };