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

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

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

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

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

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

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

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

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

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

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