@aws-sdk/client-shield 3.183.0 → 3.186.0

package/dist-es/ShieldClient.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -8,26 +9,31 @@ import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-sig
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-export class ShieldClient extends __Client {
-    constructor(configuration) {
-        const _config_0 = __getRuntimeConfig(configuration);
-        const _config_1 = resolveRegionConfig(_config_0);
-        const _config_2 = resolveEndpointsConfig(_config_1);
-        const _config_3 = resolveRetryConfig(_config_2);
-        const _config_4 = resolveHostHeaderConfig(_config_3);
-        const _config_5 = resolveAwsAuthConfig(_config_4);
-        const _config_6 = resolveUserAgentConfig(_config_5);
-        super(_config_6);
-        this.config = _config_6;
-        this.middlewareStack.use(getRetryPlugin(this.config));
-        this.middlewareStack.use(getContentLengthPlugin(this.config));
-        this.middlewareStack.use(getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(getLoggerPlugin(this.config));
-        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(getAwsAuthPlugin(this.config));
-        this.middlewareStack.use(getUserAgentPlugin(this.config));
+var ShieldClient = (function (_super) {
+    __extends(ShieldClient, _super);
+    function ShieldClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
     }
-    destroy() {
-        super.destroy();
-    }
-}
+    ShieldClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return ShieldClient;
+}(__Client));
+export { ShieldClient };

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

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

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

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

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

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

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

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

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