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

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

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

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

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

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

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

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

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

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

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