@aws-sdk/client-auditmanager 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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