@aws-sdk/client-iot-wireless 3.181.0 → 3.183.0

package/dist-es/commands/CreateDeviceProfileCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateDeviceProfileRequestFilterSensitiveLog, CreateDeviceProfileResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateDeviceProfileCommand, serializeAws_restJson1CreateDeviceProfileCommand, } from "../protocols/Aws_restJson1";
-var CreateDeviceProfileCommand = (function (_super) {
-    __extends(CreateDeviceProfileCommand, _super);
-    function CreateDeviceProfileCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDeviceProfileCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDeviceProfileCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateDeviceProfileCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateDeviceProfileCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDeviceProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDeviceProfileResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDeviceProfileCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateDeviceProfileCommand(input, context);
-    };
-    CreateDeviceProfileCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateDeviceProfileCommand(output, context);
-    };
-    return CreateDeviceProfileCommand;
-}($Command));
-export { CreateDeviceProfileCommand };
+    }
+}

package/dist-es/commands/CreateFuotaTaskCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateFuotaTaskRequestFilterSensitiveLog, CreateFuotaTaskResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateFuotaTaskCommand, serializeAws_restJson1CreateFuotaTaskCommand, } from "../protocols/Aws_restJson1";
-var CreateFuotaTaskCommand = (function (_super) {
-    __extends(CreateFuotaTaskCommand, _super);
-    function CreateFuotaTaskCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateFuotaTaskCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateFuotaTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateFuotaTaskCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateFuotaTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateFuotaTaskRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateFuotaTaskResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateFuotaTaskCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateFuotaTaskCommand(input, context);
-    };
-    CreateFuotaTaskCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateFuotaTaskCommand(output, context);
-    };
-    return CreateFuotaTaskCommand;
-}($Command));
-export { CreateFuotaTaskCommand };
+    }
+}

package/dist-es/commands/CreateMulticastGroupCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateMulticastGroupRequestFilterSensitiveLog, CreateMulticastGroupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateMulticastGroupCommand, serializeAws_restJson1CreateMulticastGroupCommand, } from "../protocols/Aws_restJson1";
-var CreateMulticastGroupCommand = (function (_super) {
-    __extends(CreateMulticastGroupCommand, _super);
-    function CreateMulticastGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateMulticastGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateMulticastGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateMulticastGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateMulticastGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateMulticastGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateMulticastGroupResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateMulticastGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateMulticastGroupCommand(input, context);
-    };
-    CreateMulticastGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateMulticastGroupCommand(output, context);
-    };
-    return CreateMulticastGroupCommand;
-}($Command));
-export { CreateMulticastGroupCommand };
+    }
+}

package/dist-es/commands/CreateNetworkAnalyzerConfigurationCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateNetworkAnalyzerConfigurationRequestFilterSensitiveLog, CreateNetworkAnalyzerConfigurationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateNetworkAnalyzerConfigurationCommand, serializeAws_restJson1CreateNetworkAnalyzerConfigurationCommand, } from "../protocols/Aws_restJson1";
-var CreateNetworkAnalyzerConfigurationCommand = (function (_super) {
-    __extends(CreateNetworkAnalyzerConfigurationCommand, _super);
-    function CreateNetworkAnalyzerConfigurationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateNetworkAnalyzerConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateNetworkAnalyzerConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateNetworkAnalyzerConfigurationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateNetworkAnalyzerConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateNetworkAnalyzerConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateNetworkAnalyzerConfigurationResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateNetworkAnalyzerConfigurationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateNetworkAnalyzerConfigurationCommand(input, context);
-    };
-    CreateNetworkAnalyzerConfigurationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateNetworkAnalyzerConfigurationCommand(output, context);
-    };
-    return CreateNetworkAnalyzerConfigurationCommand;
-}($Command));
-export { CreateNetworkAnalyzerConfigurationCommand };
+    }
+}

package/dist-es/commands/CreateServiceProfileCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateServiceProfileRequestFilterSensitiveLog, CreateServiceProfileResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateServiceProfileCommand, serializeAws_restJson1CreateServiceProfileCommand, } from "../protocols/Aws_restJson1";
-var CreateServiceProfileCommand = (function (_super) {
-    __extends(CreateServiceProfileCommand, _super);
-    function CreateServiceProfileCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateServiceProfileCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateServiceProfileCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateServiceProfileCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateServiceProfileCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateServiceProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateServiceProfileResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateServiceProfileCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateServiceProfileCommand(input, context);
-    };
-    CreateServiceProfileCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateServiceProfileCommand(output, context);
-    };
-    return CreateServiceProfileCommand;
-}($Command));
-export { CreateServiceProfileCommand };
+    }
+}

package/dist-es/commands/CreateWirelessDeviceCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateWirelessDeviceRequestFilterSensitiveLog, CreateWirelessDeviceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateWirelessDeviceCommand, serializeAws_restJson1CreateWirelessDeviceCommand, } from "../protocols/Aws_restJson1";
-var CreateWirelessDeviceCommand = (function (_super) {
-    __extends(CreateWirelessDeviceCommand, _super);
-    function CreateWirelessDeviceCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateWirelessDeviceCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateWirelessDeviceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateWirelessDeviceCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateWirelessDeviceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateWirelessDeviceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateWirelessDeviceResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateWirelessDeviceCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateWirelessDeviceCommand(input, context);
-    };
-    CreateWirelessDeviceCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateWirelessDeviceCommand(output, context);
-    };
-    return CreateWirelessDeviceCommand;
-}($Command));
-export { CreateWirelessDeviceCommand };
+    }
+}

package/dist-es/commands/CreateWirelessGatewayCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateWirelessGatewayRequestFilterSensitiveLog, CreateWirelessGatewayResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateWirelessGatewayCommand, serializeAws_restJson1CreateWirelessGatewayCommand, } from "../protocols/Aws_restJson1";
-var CreateWirelessGatewayCommand = (function (_super) {
-    __extends(CreateWirelessGatewayCommand, _super);
-    function CreateWirelessGatewayCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateWirelessGatewayCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateWirelessGatewayCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateWirelessGatewayCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateWirelessGatewayCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateWirelessGatewayRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateWirelessGatewayResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateWirelessGatewayCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateWirelessGatewayCommand(input, context);
-    };
-    CreateWirelessGatewayCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateWirelessGatewayCommand(output, context);
-    };
-    return CreateWirelessGatewayCommand;
-}($Command));
-export { CreateWirelessGatewayCommand };
+    }
+}

package/dist-es/commands/CreateWirelessGatewayTaskCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateWirelessGatewayTaskRequestFilterSensitiveLog, CreateWirelessGatewayTaskResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateWirelessGatewayTaskCommand, serializeAws_restJson1CreateWirelessGatewayTaskCommand, } from "../protocols/Aws_restJson1";
-var CreateWirelessGatewayTaskCommand = (function (_super) {
-    __extends(CreateWirelessGatewayTaskCommand, _super);
-    function CreateWirelessGatewayTaskCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateWirelessGatewayTaskCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateWirelessGatewayTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateWirelessGatewayTaskCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateWirelessGatewayTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateWirelessGatewayTaskRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateWirelessGatewayTaskResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateWirelessGatewayTaskCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateWirelessGatewayTaskCommand(input, context);
-    };
-    CreateWirelessGatewayTaskCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateWirelessGatewayTaskCommand(output, context);
-    };
-    return CreateWirelessGatewayTaskCommand;
-}($Command));
-export { CreateWirelessGatewayTaskCommand };
+    }
+}

package/dist-es/commands/CreateWirelessGatewayTaskDefinitionCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateWirelessGatewayTaskDefinitionRequestFilterSensitiveLog, CreateWirelessGatewayTaskDefinitionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateWirelessGatewayTaskDefinitionCommand, serializeAws_restJson1CreateWirelessGatewayTaskDefinitionCommand, } from "../protocols/Aws_restJson1";
-var CreateWirelessGatewayTaskDefinitionCommand = (function (_super) {
-    __extends(CreateWirelessGatewayTaskDefinitionCommand, _super);
-    function CreateWirelessGatewayTaskDefinitionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateWirelessGatewayTaskDefinitionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateWirelessGatewayTaskDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "CreateWirelessGatewayTaskDefinitionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "CreateWirelessGatewayTaskDefinitionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateWirelessGatewayTaskDefinitionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateWirelessGatewayTaskDefinitionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateWirelessGatewayTaskDefinitionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1CreateWirelessGatewayTaskDefinitionCommand(input, context);
-    };
-    CreateWirelessGatewayTaskDefinitionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1CreateWirelessGatewayTaskDefinitionCommand(output, context);
-    };
-    return CreateWirelessGatewayTaskDefinitionCommand;
-}($Command));
-export { CreateWirelessGatewayTaskDefinitionCommand };
+    }
+}

package/dist-es/commands/DeleteDestinationCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteDestinationRequestFilterSensitiveLog, DeleteDestinationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteDestinationCommand, serializeAws_restJson1DeleteDestinationCommand, } from "../protocols/Aws_restJson1";
-var DeleteDestinationCommand = (function (_super) {
-    __extends(DeleteDestinationCommand, _super);
-    function DeleteDestinationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DeleteDestinationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DeleteDestinationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTWirelessClient";
-        var commandName = "DeleteDestinationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "DeleteDestinationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DeleteDestinationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteDestinationResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DeleteDestinationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1DeleteDestinationCommand(input, context);
-    };
-    DeleteDestinationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1DeleteDestinationCommand(output, context);
-    };
-    return DeleteDestinationCommand;
-}($Command));
-export { DeleteDestinationCommand };
+    }
+}