@aws-sdk/client-auditmanager 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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