@aws-sdk/client-iot-wireless 3.39.0 → 3.43.0

package/dist-es/commands/AssociateWirelessDeviceWithFuotaTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AssociateWirelessDeviceWithFuotaTaskRequest, AssociateWirelessDeviceWithFuotaTaskResponse, } from "../models/models_0";
+import { deserializeAws_restJson1AssociateWirelessDeviceWithFuotaTaskCommand, serializeAws_restJson1AssociateWirelessDeviceWithFuotaTaskCommand, } from "../protocols/Aws_restJson1";
+var AssociateWirelessDeviceWithFuotaTaskCommand = (function (_super) {
+    __extends(AssociateWirelessDeviceWithFuotaTaskCommand, _super);
+    function AssociateWirelessDeviceWithFuotaTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateWirelessDeviceWithFuotaTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "AssociateWirelessDeviceWithFuotaTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateWirelessDeviceWithFuotaTaskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssociateWirelessDeviceWithFuotaTaskResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateWirelessDeviceWithFuotaTaskCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateWirelessDeviceWithFuotaTaskCommand(input, context);
+    };
+    AssociateWirelessDeviceWithFuotaTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateWirelessDeviceWithFuotaTaskCommand(output, context);
+    };
+    return AssociateWirelessDeviceWithFuotaTaskCommand;
+}($Command));
+export { AssociateWirelessDeviceWithFuotaTaskCommand };

package/dist-es/commands/AssociateWirelessDeviceWithMulticastGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AssociateWirelessDeviceWithMulticastGroupRequest, AssociateWirelessDeviceWithMulticastGroupResponse, } from "../models/models_0";
+import { deserializeAws_restJson1AssociateWirelessDeviceWithMulticastGroupCommand, serializeAws_restJson1AssociateWirelessDeviceWithMulticastGroupCommand, } from "../protocols/Aws_restJson1";
+var AssociateWirelessDeviceWithMulticastGroupCommand = (function (_super) {
+    __extends(AssociateWirelessDeviceWithMulticastGroupCommand, _super);
+    function AssociateWirelessDeviceWithMulticastGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateWirelessDeviceWithMulticastGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "AssociateWirelessDeviceWithMulticastGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateWirelessDeviceWithMulticastGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssociateWirelessDeviceWithMulticastGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateWirelessDeviceWithMulticastGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateWirelessDeviceWithMulticastGroupCommand(input, context);
+    };
+    AssociateWirelessDeviceWithMulticastGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateWirelessDeviceWithMulticastGroupCommand(output, context);
+    };
+    return AssociateWirelessDeviceWithMulticastGroupCommand;
+}($Command));
+export { AssociateWirelessDeviceWithMulticastGroupCommand };

package/dist-es/commands/CancelMulticastGroupSessionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CancelMulticastGroupSessionRequest, CancelMulticastGroupSessionResponse } from "../models/models_0";
+import { deserializeAws_restJson1CancelMulticastGroupSessionCommand, serializeAws_restJson1CancelMulticastGroupSessionCommand, } from "../protocols/Aws_restJson1";
+var CancelMulticastGroupSessionCommand = (function (_super) {
+    __extends(CancelMulticastGroupSessionCommand, _super);
+    function CancelMulticastGroupSessionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CancelMulticastGroupSessionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "CancelMulticastGroupSessionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CancelMulticastGroupSessionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CancelMulticastGroupSessionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CancelMulticastGroupSessionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CancelMulticastGroupSessionCommand(input, context);
+    };
+    CancelMulticastGroupSessionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CancelMulticastGroupSessionCommand(output, context);
+    };
+    return CancelMulticastGroupSessionCommand;
+}($Command));
+export { CancelMulticastGroupSessionCommand };

package/dist-es/commands/CreateFuotaTaskCommand.js

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

package/dist-es/commands/CreateMulticastGroupCommand.js

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

package/dist-es/commands/DeleteFuotaTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteFuotaTaskRequest, DeleteFuotaTaskResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteFuotaTaskCommand, serializeAws_restJson1DeleteFuotaTaskCommand, } from "../protocols/Aws_restJson1";
+var DeleteFuotaTaskCommand = (function (_super) {
+    __extends(DeleteFuotaTaskCommand, _super);
+    function DeleteFuotaTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteFuotaTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "DeleteFuotaTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteFuotaTaskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteFuotaTaskResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteFuotaTaskCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteFuotaTaskCommand(input, context);
+    };
+    DeleteFuotaTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteFuotaTaskCommand(output, context);
+    };
+    return DeleteFuotaTaskCommand;
+}($Command));
+export { DeleteFuotaTaskCommand };

package/dist-es/commands/DeleteMulticastGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteMulticastGroupRequest, DeleteMulticastGroupResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteMulticastGroupCommand, serializeAws_restJson1DeleteMulticastGroupCommand, } from "../protocols/Aws_restJson1";
+var DeleteMulticastGroupCommand = (function (_super) {
+    __extends(DeleteMulticastGroupCommand, _super);
+    function DeleteMulticastGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteMulticastGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "DeleteMulticastGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteMulticastGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteMulticastGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteMulticastGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteMulticastGroupCommand(input, context);
+    };
+    DeleteMulticastGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteMulticastGroupCommand(output, context);
+    };
+    return DeleteMulticastGroupCommand;
+}($Command));
+export { DeleteMulticastGroupCommand };

package/dist-es/commands/DisassociateMulticastGroupFromFuotaTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DisassociateMulticastGroupFromFuotaTaskRequest, DisassociateMulticastGroupFromFuotaTaskResponse, } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateMulticastGroupFromFuotaTaskCommand, serializeAws_restJson1DisassociateMulticastGroupFromFuotaTaskCommand, } from "../protocols/Aws_restJson1";
+var DisassociateMulticastGroupFromFuotaTaskCommand = (function (_super) {
+    __extends(DisassociateMulticastGroupFromFuotaTaskCommand, _super);
+    function DisassociateMulticastGroupFromFuotaTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateMulticastGroupFromFuotaTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "DisassociateMulticastGroupFromFuotaTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateMulticastGroupFromFuotaTaskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateMulticastGroupFromFuotaTaskResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    DisassociateMulticastGroupFromFuotaTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DisassociateMulticastGroupFromFuotaTaskCommand(output, context);
+    };
+    return DisassociateMulticastGroupFromFuotaTaskCommand;
+}($Command));
+export { DisassociateMulticastGroupFromFuotaTaskCommand };

package/dist-es/commands/DisassociateWirelessDeviceFromFuotaTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DisassociateWirelessDeviceFromFuotaTaskRequest, DisassociateWirelessDeviceFromFuotaTaskResponse, } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateWirelessDeviceFromFuotaTaskCommand, serializeAws_restJson1DisassociateWirelessDeviceFromFuotaTaskCommand, } from "../protocols/Aws_restJson1";
+var DisassociateWirelessDeviceFromFuotaTaskCommand = (function (_super) {
+    __extends(DisassociateWirelessDeviceFromFuotaTaskCommand, _super);
+    function DisassociateWirelessDeviceFromFuotaTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateWirelessDeviceFromFuotaTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "DisassociateWirelessDeviceFromFuotaTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateWirelessDeviceFromFuotaTaskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateWirelessDeviceFromFuotaTaskResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    DisassociateWirelessDeviceFromFuotaTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DisassociateWirelessDeviceFromFuotaTaskCommand(output, context);
+    };
+    return DisassociateWirelessDeviceFromFuotaTaskCommand;
+}($Command));
+export { DisassociateWirelessDeviceFromFuotaTaskCommand };

package/dist-es/commands/DisassociateWirelessDeviceFromMulticastGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DisassociateWirelessDeviceFromMulticastGroupRequest, DisassociateWirelessDeviceFromMulticastGroupResponse, } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateWirelessDeviceFromMulticastGroupCommand, serializeAws_restJson1DisassociateWirelessDeviceFromMulticastGroupCommand, } from "../protocols/Aws_restJson1";
+var DisassociateWirelessDeviceFromMulticastGroupCommand = (function (_super) {
+    __extends(DisassociateWirelessDeviceFromMulticastGroupCommand, _super);
+    function DisassociateWirelessDeviceFromMulticastGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateWirelessDeviceFromMulticastGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "DisassociateWirelessDeviceFromMulticastGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateWirelessDeviceFromMulticastGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateWirelessDeviceFromMulticastGroupResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    DisassociateWirelessDeviceFromMulticastGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DisassociateWirelessDeviceFromMulticastGroupCommand(output, context);
+    };
+    return DisassociateWirelessDeviceFromMulticastGroupCommand;
+}($Command));
+export { DisassociateWirelessDeviceFromMulticastGroupCommand };

package/dist-es/commands/GetFuotaTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetFuotaTaskRequest, GetFuotaTaskResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetFuotaTaskCommand, serializeAws_restJson1GetFuotaTaskCommand, } from "../protocols/Aws_restJson1";
+var GetFuotaTaskCommand = (function (_super) {
+    __extends(GetFuotaTaskCommand, _super);
+    function GetFuotaTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFuotaTaskCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "GetFuotaTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFuotaTaskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFuotaTaskResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFuotaTaskCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFuotaTaskCommand(input, context);
+    };
+    GetFuotaTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFuotaTaskCommand(output, context);
+    };
+    return GetFuotaTaskCommand;
+}($Command));
+export { GetFuotaTaskCommand };

package/dist-es/commands/GetMulticastGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetMulticastGroupRequest, GetMulticastGroupResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetMulticastGroupCommand, serializeAws_restJson1GetMulticastGroupCommand, } from "../protocols/Aws_restJson1";
+var GetMulticastGroupCommand = (function (_super) {
+    __extends(GetMulticastGroupCommand, _super);
+    function GetMulticastGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetMulticastGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "GetMulticastGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetMulticastGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetMulticastGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMulticastGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetMulticastGroupCommand(input, context);
+    };
+    GetMulticastGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetMulticastGroupCommand(output, context);
+    };
+    return GetMulticastGroupCommand;
+}($Command));
+export { GetMulticastGroupCommand };

package/dist-es/commands/GetMulticastGroupSessionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetMulticastGroupSessionRequest, GetMulticastGroupSessionResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetMulticastGroupSessionCommand, serializeAws_restJson1GetMulticastGroupSessionCommand, } from "../protocols/Aws_restJson1";
+var GetMulticastGroupSessionCommand = (function (_super) {
+    __extends(GetMulticastGroupSessionCommand, _super);
+    function GetMulticastGroupSessionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetMulticastGroupSessionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "GetMulticastGroupSessionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetMulticastGroupSessionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetMulticastGroupSessionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMulticastGroupSessionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetMulticastGroupSessionCommand(input, context);
+    };
+    GetMulticastGroupSessionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetMulticastGroupSessionCommand(output, context);
+    };
+    return GetMulticastGroupSessionCommand;
+}($Command));
+export { GetMulticastGroupSessionCommand };

package/dist-es/commands/GetNetworkAnalyzerConfigurationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetNetworkAnalyzerConfigurationRequest, GetNetworkAnalyzerConfigurationResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetNetworkAnalyzerConfigurationCommand, serializeAws_restJson1GetNetworkAnalyzerConfigurationCommand, } from "../protocols/Aws_restJson1";
+var GetNetworkAnalyzerConfigurationCommand = (function (_super) {
+    __extends(GetNetworkAnalyzerConfigurationCommand, _super);
+    function GetNetworkAnalyzerConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetNetworkAnalyzerConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "GetNetworkAnalyzerConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetNetworkAnalyzerConfigurationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetNetworkAnalyzerConfigurationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetNetworkAnalyzerConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetNetworkAnalyzerConfigurationCommand(input, context);
+    };
+    GetNetworkAnalyzerConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetNetworkAnalyzerConfigurationCommand(output, context);
+    };
+    return GetNetworkAnalyzerConfigurationCommand;
+}($Command));
+export { GetNetworkAnalyzerConfigurationCommand };

package/dist-es/commands/GetResourceEventConfigurationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetResourceEventConfigurationRequest, GetResourceEventConfigurationResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetResourceEventConfigurationCommand, serializeAws_restJson1GetResourceEventConfigurationCommand, } from "../protocols/Aws_restJson1";
+var GetResourceEventConfigurationCommand = (function (_super) {
+    __extends(GetResourceEventConfigurationCommand, _super);
+    function GetResourceEventConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResourceEventConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "GetResourceEventConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResourceEventConfigurationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResourceEventConfigurationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResourceEventConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetResourceEventConfigurationCommand(input, context);
+    };
+    GetResourceEventConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetResourceEventConfigurationCommand(output, context);
+    };
+    return GetResourceEventConfigurationCommand;
+}($Command));
+export { GetResourceEventConfigurationCommand };

package/dist-es/commands/ListFuotaTasksCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFuotaTasksRequest, ListFuotaTasksResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListFuotaTasksCommand, serializeAws_restJson1ListFuotaTasksCommand, } from "../protocols/Aws_restJson1";
+var ListFuotaTasksCommand = (function (_super) {
+    __extends(ListFuotaTasksCommand, _super);
+    function ListFuotaTasksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListFuotaTasksCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTWirelessClient";
+        var commandName = "ListFuotaTasksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListFuotaTasksRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListFuotaTasksResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    ListFuotaTasksCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListFuotaTasksCommand(output, context);
+    };
+    return ListFuotaTasksCommand;
+}($Command));
+export { ListFuotaTasksCommand };