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

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

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

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

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

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

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

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

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

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

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