@aws-sdk/client-inspector2 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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