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

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

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

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

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

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

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

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

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

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

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