@aws-sdk/client-ssm-incidents 3.183.0 → 3.185.0

package/dist-es/commands/CreateReplicationSetCommand.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 { CreateReplicationSetInputFilterSensitiveLog, CreateReplicationSetOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateReplicationSetCommand, serializeAws_restJson1CreateReplicationSetCommand, } from "../protocols/Aws_restJson1";
-export class CreateReplicationSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateReplicationSetCommand = (function (_super) {
+    __extends(CreateReplicationSetCommand, _super);
+    function CreateReplicationSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateReplicationSetCommand.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 = "SSMIncidentsClient";
-        const commandName = "CreateReplicationSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "CreateReplicationSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateReplicationSetInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateReplicationSetOutputFilterSensitiveLog,
         };
-        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);
+    };
+    CreateReplicationSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateReplicationSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateReplicationSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateReplicationSetCommand(output, context);
-    }
-}
+    };
+    return CreateReplicationSetCommand;
+}($Command));
+export { CreateReplicationSetCommand };

package/dist-es/commands/CreateResponsePlanCommand.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 { CreateResponsePlanInputFilterSensitiveLog, CreateResponsePlanOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateResponsePlanCommand, serializeAws_restJson1CreateResponsePlanCommand, } from "../protocols/Aws_restJson1";
-export class CreateResponsePlanCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateResponsePlanCommand = (function (_super) {
+    __extends(CreateResponsePlanCommand, _super);
+    function CreateResponsePlanCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateResponsePlanCommand.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 = "SSMIncidentsClient";
-        const commandName = "CreateResponsePlanCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "CreateResponsePlanCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateResponsePlanInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateResponsePlanOutputFilterSensitiveLog,
         };
-        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);
+    };
+    CreateResponsePlanCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateResponsePlanCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateResponsePlanCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateResponsePlanCommand(output, context);
-    }
-}
+    };
+    return CreateResponsePlanCommand;
+}($Command));
+export { CreateResponsePlanCommand };

package/dist-es/commands/CreateTimelineEventCommand.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 { CreateTimelineEventInputFilterSensitiveLog, CreateTimelineEventOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateTimelineEventCommand, serializeAws_restJson1CreateTimelineEventCommand, } from "../protocols/Aws_restJson1";
-export class CreateTimelineEventCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTimelineEventCommand = (function (_super) {
+    __extends(CreateTimelineEventCommand, _super);
+    function CreateTimelineEventCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTimelineEventCommand.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 = "SSMIncidentsClient";
-        const commandName = "CreateTimelineEventCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "CreateTimelineEventCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTimelineEventInputFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTimelineEventOutputFilterSensitiveLog,
         };
-        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);
+    };
+    CreateTimelineEventCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateTimelineEventCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTimelineEventCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateTimelineEventCommand(output, context);
-    }
-}
+    };
+    return CreateTimelineEventCommand;
+}($Command));
+export { CreateTimelineEventCommand };

package/dist-es/commands/DeleteIncidentRecordCommand.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 { DeleteIncidentRecordInputFilterSensitiveLog, DeleteIncidentRecordOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteIncidentRecordCommand, serializeAws_restJson1DeleteIncidentRecordCommand, } from "../protocols/Aws_restJson1";
-export class DeleteIncidentRecordCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteIncidentRecordCommand = (function (_super) {
+    __extends(DeleteIncidentRecordCommand, _super);
+    function DeleteIncidentRecordCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteIncidentRecordCommand.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 = "SSMIncidentsClient";
-        const commandName = "DeleteIncidentRecordCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "DeleteIncidentRecordCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteIncidentRecordInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteIncidentRecordOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteIncidentRecordCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteIncidentRecordCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteIncidentRecordCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteIncidentRecordCommand(output, context);
-    }
-}
+    };
+    return DeleteIncidentRecordCommand;
+}($Command));
+export { DeleteIncidentRecordCommand };

package/dist-es/commands/DeleteReplicationSetCommand.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 { DeleteReplicationSetInputFilterSensitiveLog, DeleteReplicationSetOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteReplicationSetCommand, serializeAws_restJson1DeleteReplicationSetCommand, } from "../protocols/Aws_restJson1";
-export class DeleteReplicationSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteReplicationSetCommand = (function (_super) {
+    __extends(DeleteReplicationSetCommand, _super);
+    function DeleteReplicationSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteReplicationSetCommand.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 = "SSMIncidentsClient";
-        const commandName = "DeleteReplicationSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "DeleteReplicationSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteReplicationSetInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteReplicationSetOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteReplicationSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteReplicationSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteReplicationSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteReplicationSetCommand(output, context);
-    }
-}
+    };
+    return DeleteReplicationSetCommand;
+}($Command));
+export { DeleteReplicationSetCommand };

package/dist-es/commands/DeleteResourcePolicyCommand.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 { DeleteResourcePolicyInputFilterSensitiveLog, DeleteResourcePolicyOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteResourcePolicyCommand, serializeAws_restJson1DeleteResourcePolicyCommand, } from "../protocols/Aws_restJson1";
-export class DeleteResourcePolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteResourcePolicyCommand = (function (_super) {
+    __extends(DeleteResourcePolicyCommand, _super);
+    function DeleteResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteResourcePolicyCommand.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 = "SSMIncidentsClient";
-        const commandName = "DeleteResourcePolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "DeleteResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteResourcePolicyInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteResourcePolicyOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteResourcePolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteResourcePolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteResourcePolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteResourcePolicyCommand(output, context);
-    }
-}
+    };
+    return DeleteResourcePolicyCommand;
+}($Command));
+export { DeleteResourcePolicyCommand };

package/dist-es/commands/DeleteResponsePlanCommand.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 { DeleteResponsePlanInputFilterSensitiveLog, DeleteResponsePlanOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteResponsePlanCommand, serializeAws_restJson1DeleteResponsePlanCommand, } from "../protocols/Aws_restJson1";
-export class DeleteResponsePlanCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteResponsePlanCommand = (function (_super) {
+    __extends(DeleteResponsePlanCommand, _super);
+    function DeleteResponsePlanCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteResponsePlanCommand.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 = "SSMIncidentsClient";
-        const commandName = "DeleteResponsePlanCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "DeleteResponsePlanCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteResponsePlanInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteResponsePlanOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteResponsePlanCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteResponsePlanCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteResponsePlanCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteResponsePlanCommand(output, context);
-    }
-}
+    };
+    return DeleteResponsePlanCommand;
+}($Command));
+export { DeleteResponsePlanCommand };

package/dist-es/commands/DeleteTimelineEventCommand.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 { DeleteTimelineEventInputFilterSensitiveLog, DeleteTimelineEventOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteTimelineEventCommand, serializeAws_restJson1DeleteTimelineEventCommand, } from "../protocols/Aws_restJson1";
-export class DeleteTimelineEventCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteTimelineEventCommand = (function (_super) {
+    __extends(DeleteTimelineEventCommand, _super);
+    function DeleteTimelineEventCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteTimelineEventCommand.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 = "SSMIncidentsClient";
-        const commandName = "DeleteTimelineEventCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "DeleteTimelineEventCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteTimelineEventInputFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteTimelineEventOutputFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteTimelineEventCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteTimelineEventCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteTimelineEventCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteTimelineEventCommand(output, context);
-    }
-}
+    };
+    return DeleteTimelineEventCommand;
+}($Command));
+export { DeleteTimelineEventCommand };

package/dist-es/commands/GetIncidentRecordCommand.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 { GetIncidentRecordInputFilterSensitiveLog, GetIncidentRecordOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetIncidentRecordCommand, serializeAws_restJson1GetIncidentRecordCommand, } from "../protocols/Aws_restJson1";
-export class GetIncidentRecordCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetIncidentRecordCommand = (function (_super) {
+    __extends(GetIncidentRecordCommand, _super);
+    function GetIncidentRecordCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetIncidentRecordCommand.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 = "SSMIncidentsClient";
-        const commandName = "GetIncidentRecordCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "GetIncidentRecordCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetIncidentRecordInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetIncidentRecordOutputFilterSensitiveLog,
         };
-        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);
+    };
+    GetIncidentRecordCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetIncidentRecordCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetIncidentRecordCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetIncidentRecordCommand(output, context);
-    }
-}
+    };
+    return GetIncidentRecordCommand;
+}($Command));
+export { GetIncidentRecordCommand };

package/dist-es/commands/GetReplicationSetCommand.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 { GetReplicationSetInputFilterSensitiveLog, GetReplicationSetOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetReplicationSetCommand, serializeAws_restJson1GetReplicationSetCommand, } from "../protocols/Aws_restJson1";
-export class GetReplicationSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetReplicationSetCommand = (function (_super) {
+    __extends(GetReplicationSetCommand, _super);
+    function GetReplicationSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetReplicationSetCommand.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 = "SSMIncidentsClient";
-        const commandName = "GetReplicationSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SSMIncidentsClient";
+        var commandName = "GetReplicationSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetReplicationSetInputFilterSensitiveLog,
             outputFilterSensitiveLog: GetReplicationSetOutputFilterSensitiveLog,
         };
-        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);
+    };
+    GetReplicationSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetReplicationSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetReplicationSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetReplicationSetCommand(output, context);
-    }
-}
+    };
+    return GetReplicationSetCommand;
+}($Command));
+export { GetReplicationSetCommand };