@aws-sdk/client-accessanalyzer 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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