@aws-sdk/client-iot-wireless 3.299.0 → 3.301.0

package/dist-es/IoTWireless.js

@@ -24,9 +24,11 @@ import { DeleteNetworkAnalyzerConfigurationCommand, } from "./commands/DeleteNet
 import { DeleteQueuedMessagesCommand, } from "./commands/DeleteQueuedMessagesCommand";
 import { DeleteServiceProfileCommand, } from "./commands/DeleteServiceProfileCommand";
 import { DeleteWirelessDeviceCommand, } from "./commands/DeleteWirelessDeviceCommand";
+import { DeleteWirelessDeviceImportTaskCommand, } from "./commands/DeleteWirelessDeviceImportTaskCommand";
 import { DeleteWirelessGatewayCommand, } from "./commands/DeleteWirelessGatewayCommand";
 import { DeleteWirelessGatewayTaskCommand, } from "./commands/DeleteWirelessGatewayTaskCommand";
 import { DeleteWirelessGatewayTaskDefinitionCommand, } from "./commands/DeleteWirelessGatewayTaskDefinitionCommand";
+import { DeregisterWirelessDeviceCommand, } from "./commands/DeregisterWirelessDeviceCommand";
 import { DisassociateAwsAccountFromPartnerAccountCommand, } from "./commands/DisassociateAwsAccountFromPartnerAccountCommand";
 import { DisassociateMulticastGroupFromFuotaTaskCommand, } from "./commands/DisassociateMulticastGroupFromFuotaTaskCommand";
 import { DisassociateWirelessDeviceFromFuotaTaskCommand, } from "./commands/DisassociateWirelessDeviceFromFuotaTaskCommand";
@@ -52,6 +54,7 @@ import { GetResourcePositionCommand, } from "./commands/GetResourcePositionComma
 import { GetServiceEndpointCommand, } from "./commands/GetServiceEndpointCommand";
 import { GetServiceProfileCommand, } from "./commands/GetServiceProfileCommand";
 import { GetWirelessDeviceCommand, } from "./commands/GetWirelessDeviceCommand";
+import { GetWirelessDeviceImportTaskCommand, } from "./commands/GetWirelessDeviceImportTaskCommand";
 import { GetWirelessDeviceStatisticsCommand, } from "./commands/GetWirelessDeviceStatisticsCommand";
 import { GetWirelessGatewayCertificateCommand, } from "./commands/GetWirelessGatewayCertificateCommand";
 import { GetWirelessGatewayCommand, } from "./commands/GetWirelessGatewayCommand";
@@ -61,6 +64,7 @@ import { GetWirelessGatewayTaskCommand, } from "./commands/GetWirelessGatewayTas
 import { GetWirelessGatewayTaskDefinitionCommand, } from "./commands/GetWirelessGatewayTaskDefinitionCommand";
 import { ListDestinationsCommand, } from "./commands/ListDestinationsCommand";
 import { ListDeviceProfilesCommand, } from "./commands/ListDeviceProfilesCommand";
+import { ListDevicesForWirelessDeviceImportTaskCommand, } from "./commands/ListDevicesForWirelessDeviceImportTaskCommand";
 import { ListEventConfigurationsCommand, } from "./commands/ListEventConfigurationsCommand";
 import { ListFuotaTasksCommand, } from "./commands/ListFuotaTasksCommand";
 import { ListMulticastGroupsByFuotaTaskCommand, } from "./commands/ListMulticastGroupsByFuotaTaskCommand";
@@ -71,6 +75,7 @@ import { ListPositionConfigurationsCommand, } from "./commands/ListPositionConfi
 import { ListQueuedMessagesCommand, } from "./commands/ListQueuedMessagesCommand";
 import { ListServiceProfilesCommand, } from "./commands/ListServiceProfilesCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { ListWirelessDeviceImportTasksCommand, } from "./commands/ListWirelessDeviceImportTasksCommand";
 import { ListWirelessDevicesCommand, } from "./commands/ListWirelessDevicesCommand";
 import { ListWirelessGatewaysCommand, } from "./commands/ListWirelessGatewaysCommand";
 import { ListWirelessGatewayTaskDefinitionsCommand, } from "./commands/ListWirelessGatewayTaskDefinitionsCommand";
@@ -84,6 +89,8 @@ import { StartBulkAssociateWirelessDeviceWithMulticastGroupCommand, } from "./co
 import { StartBulkDisassociateWirelessDeviceFromMulticastGroupCommand, } from "./commands/StartBulkDisassociateWirelessDeviceFromMulticastGroupCommand";
 import { StartFuotaTaskCommand, } from "./commands/StartFuotaTaskCommand";
 import { StartMulticastGroupSessionCommand, } from "./commands/StartMulticastGroupSessionCommand";
+import { StartSingleWirelessDeviceImportTaskCommand, } from "./commands/StartSingleWirelessDeviceImportTaskCommand";
+import { StartWirelessDeviceImportTaskCommand, } from "./commands/StartWirelessDeviceImportTaskCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { TestWirelessDeviceCommand, } from "./commands/TestWirelessDeviceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
@@ -98,6 +105,7 @@ import { UpdatePositionCommand, } from "./commands/UpdatePositionCommand";
 import { UpdateResourceEventConfigurationCommand, } from "./commands/UpdateResourceEventConfigurationCommand";
 import { UpdateResourcePositionCommand, } from "./commands/UpdateResourcePositionCommand";
 import { UpdateWirelessDeviceCommand, } from "./commands/UpdateWirelessDeviceCommand";
+import { UpdateWirelessDeviceImportTaskCommand, } from "./commands/UpdateWirelessDeviceImportTaskCommand";
 import { UpdateWirelessGatewayCommand, } from "./commands/UpdateWirelessGatewayCommand";
 import { IoTWirelessClient } from "./IoTWirelessClient";
 export class IoTWireless extends IoTWirelessClient {
@@ -465,6 +473,20 @@ export class IoTWireless extends IoTWirelessClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteWirelessDeviceImportTask(args, optionsOrCb, cb) {
+        const command = new DeleteWirelessDeviceImportTaskCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteWirelessGateway(args, optionsOrCb, cb) {
         const command = new DeleteWirelessGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -507,6 +529,20 @@ export class IoTWireless extends IoTWirelessClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deregisterWirelessDevice(args, optionsOrCb, cb) {
+        const command = new DeregisterWirelessDeviceCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     disassociateAwsAccountFromPartnerAccount(args, optionsOrCb, cb) {
         const command = new DisassociateAwsAccountFromPartnerAccountCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -857,6 +893,20 @@ export class IoTWireless extends IoTWirelessClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getWirelessDeviceImportTask(args, optionsOrCb, cb) {
+        const command = new GetWirelessDeviceImportTaskCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     getWirelessDeviceStatistics(args, optionsOrCb, cb) {
         const command = new GetWirelessDeviceStatisticsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -983,6 +1033,20 @@ export class IoTWireless extends IoTWirelessClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listDevicesForWirelessDeviceImportTask(args, optionsOrCb, cb) {
+        const command = new ListDevicesForWirelessDeviceImportTaskCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listEventConfigurations(args, optionsOrCb, cb) {
         const command = new ListEventConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -1123,6 +1187,20 @@ export class IoTWireless extends IoTWirelessClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listWirelessDeviceImportTasks(args, optionsOrCb, cb) {
+        const command = new ListWirelessDeviceImportTasksCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listWirelessDevices(args, optionsOrCb, cb) {
         const command = new ListWirelessDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -1305,6 +1383,34 @@ export class IoTWireless extends IoTWirelessClient {
             return this.send(command, optionsOrCb);
         }
     }
+    startSingleWirelessDeviceImportTask(args, optionsOrCb, cb) {
+        const command = new StartSingleWirelessDeviceImportTaskCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    startWirelessDeviceImportTask(args, optionsOrCb, cb) {
+        const command = new StartWirelessDeviceImportTaskCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     tagResource(args, optionsOrCb, cb) {
         const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -1501,6 +1607,20 @@ export class IoTWireless extends IoTWirelessClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateWirelessDeviceImportTask(args, optionsOrCb, cb) {
+        const command = new UpdateWirelessDeviceImportTaskCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updateWirelessGateway(args, optionsOrCb, cb) {
         const command = new UpdateWirelessGatewayCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/DeleteWirelessDeviceImportTaskCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1DeleteWirelessDeviceImportTaskCommand, serializeAws_restJson1DeleteWirelessDeviceImportTaskCommand, } from "../protocols/Aws_restJson1";
+export class DeleteWirelessDeviceImportTaskCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteWirelessDeviceImportTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "DeleteWirelessDeviceImportTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteWirelessDeviceImportTaskCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteWirelessDeviceImportTaskCommand(output, context);
+    }
+}

package/dist-es/commands/DeregisterWirelessDeviceCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1DeregisterWirelessDeviceCommand, serializeAws_restJson1DeregisterWirelessDeviceCommand, } from "../protocols/Aws_restJson1";
+export class DeregisterWirelessDeviceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeregisterWirelessDeviceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "DeregisterWirelessDeviceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeregisterWirelessDeviceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeregisterWirelessDeviceCommand(output, context);
+    }
+}

package/dist-es/commands/GetDeviceProfileCommand.js

@@ -1,6 +1,7 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetDeviceProfileResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetDeviceProfileCommand, serializeAws_restJson1GetDeviceProfileCommand, } from "../protocols/Aws_restJson1";
 export class GetDeviceProfileCommand extends $Command {
     static getEndpointParameterInstructions() {
@@ -27,7 +28,7 @@ export class GetDeviceProfileCommand extends $Command {
             clientName,
             commandName,
             inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: GetDeviceProfileResponseFilterSensitiveLog,
         };
         const { requestHandler } = configuration;
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);

package/dist-es/commands/GetWirelessDeviceImportTaskCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1GetWirelessDeviceImportTaskCommand, serializeAws_restJson1GetWirelessDeviceImportTaskCommand, } from "../protocols/Aws_restJson1";
+export class GetWirelessDeviceImportTaskCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetWirelessDeviceImportTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "GetWirelessDeviceImportTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetWirelessDeviceImportTaskCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetWirelessDeviceImportTaskCommand(output, context);
+    }
+}

package/dist-es/commands/ListDevicesForWirelessDeviceImportTaskCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommand, serializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommand, } from "../protocols/Aws_restJson1";
+export class ListDevicesForWirelessDeviceImportTaskCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListDevicesForWirelessDeviceImportTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "ListDevicesForWirelessDeviceImportTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommand(output, context);
+    }
+}

package/dist-es/commands/ListWirelessDeviceImportTasksCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1ListWirelessDeviceImportTasksCommand, serializeAws_restJson1ListWirelessDeviceImportTasksCommand, } from "../protocols/Aws_restJson1";
+export class ListWirelessDeviceImportTasksCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListWirelessDeviceImportTasksCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "ListWirelessDeviceImportTasksCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListWirelessDeviceImportTasksCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListWirelessDeviceImportTasksCommand(output, context);
+    }
+}

package/dist-es/commands/StartSingleWirelessDeviceImportTaskCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1StartSingleWirelessDeviceImportTaskCommand, serializeAws_restJson1StartSingleWirelessDeviceImportTaskCommand, } from "../protocols/Aws_restJson1";
+export class StartSingleWirelessDeviceImportTaskCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartSingleWirelessDeviceImportTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "StartSingleWirelessDeviceImportTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartSingleWirelessDeviceImportTaskCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartSingleWirelessDeviceImportTaskCommand(output, context);
+    }
+}

package/dist-es/commands/StartWirelessDeviceImportTaskCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1StartWirelessDeviceImportTaskCommand, serializeAws_restJson1StartWirelessDeviceImportTaskCommand, } from "../protocols/Aws_restJson1";
+export class StartWirelessDeviceImportTaskCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartWirelessDeviceImportTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "StartWirelessDeviceImportTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartWirelessDeviceImportTaskCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartWirelessDeviceImportTaskCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateWirelessDeviceImportTaskCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { deserializeAws_restJson1UpdateWirelessDeviceImportTaskCommand, serializeAws_restJson1UpdateWirelessDeviceImportTaskCommand, } from "../protocols/Aws_restJson1";
+export class UpdateWirelessDeviceImportTaskCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateWirelessDeviceImportTaskCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTWirelessClient";
+        const commandName = "UpdateWirelessDeviceImportTaskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateWirelessDeviceImportTaskCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateWirelessDeviceImportTaskCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -24,9 +24,11 @@ export * from "./DeleteNetworkAnalyzerConfigurationCommand";
 export * from "./DeleteQueuedMessagesCommand";
 export * from "./DeleteServiceProfileCommand";
 export * from "./DeleteWirelessDeviceCommand";
+export * from "./DeleteWirelessDeviceImportTaskCommand";
 export * from "./DeleteWirelessGatewayCommand";
 export * from "./DeleteWirelessGatewayTaskCommand";
 export * from "./DeleteWirelessGatewayTaskDefinitionCommand";
+export * from "./DeregisterWirelessDeviceCommand";
 export * from "./DisassociateAwsAccountFromPartnerAccountCommand";
 export * from "./DisassociateMulticastGroupFromFuotaTaskCommand";
 export * from "./DisassociateWirelessDeviceFromFuotaTaskCommand";
@@ -52,6 +54,7 @@ export * from "./GetResourcePositionCommand";
 export * from "./GetServiceEndpointCommand";
 export * from "./GetServiceProfileCommand";
 export * from "./GetWirelessDeviceCommand";
+export * from "./GetWirelessDeviceImportTaskCommand";
 export * from "./GetWirelessDeviceStatisticsCommand";
 export * from "./GetWirelessGatewayCertificateCommand";
 export * from "./GetWirelessGatewayCommand";
@@ -61,6 +64,7 @@ export * from "./GetWirelessGatewayTaskCommand";
 export * from "./GetWirelessGatewayTaskDefinitionCommand";
 export * from "./ListDestinationsCommand";
 export * from "./ListDeviceProfilesCommand";
+export * from "./ListDevicesForWirelessDeviceImportTaskCommand";
 export * from "./ListEventConfigurationsCommand";
 export * from "./ListFuotaTasksCommand";
 export * from "./ListMulticastGroupsByFuotaTaskCommand";
@@ -71,6 +75,7 @@ export * from "./ListPositionConfigurationsCommand";
 export * from "./ListQueuedMessagesCommand";
 export * from "./ListServiceProfilesCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./ListWirelessDeviceImportTasksCommand";
 export * from "./ListWirelessDevicesCommand";
 export * from "./ListWirelessGatewayTaskDefinitionsCommand";
 export * from "./ListWirelessGatewaysCommand";
@@ -84,6 +89,8 @@ export * from "./StartBulkAssociateWirelessDeviceWithMulticastGroupCommand";
 export * from "./StartBulkDisassociateWirelessDeviceFromMulticastGroupCommand";
 export * from "./StartFuotaTaskCommand";
 export * from "./StartMulticastGroupSessionCommand";
+export * from "./StartSingleWirelessDeviceImportTaskCommand";
+export * from "./StartWirelessDeviceImportTaskCommand";
 export * from "./TagResourceCommand";
 export * from "./TestWirelessDeviceCommand";
 export * from "./UntagResourceCommand";
@@ -98,4 +105,5 @@ export * from "./UpdatePositionCommand";
 export * from "./UpdateResourceEventConfigurationCommand";
 export * from "./UpdateResourcePositionCommand";
 export * from "./UpdateWirelessDeviceCommand";
+export * from "./UpdateWirelessDeviceImportTaskCommand";
 export * from "./UpdateWirelessGatewayCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const s = "required", t = "fn", u = "argv", v = "ref";
-const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = "stringEquals", g = { [s]: false, "type": "String" }, h = { [s]: true, "default": false, "type": "Boolean" }, i = { [v]: "Endpoint" }, j = { [t]: "booleanEquals", [u]: [{ [v]: "UseFIPS" }, true] }, k = { [t]: "booleanEquals", [u]: [{ [v]: "UseDualStack" }, true] }, l = {}, m = { [v]: "Region" }, n = { [t]: "booleanEquals", [u]: [true, { [t]: "getAttr", [u]: [{ [v]: e }, "supportsFIPS"] }] }, o = { [t]: "booleanEquals", [u]: [true, { [t]: "getAttr", [u]: [{ [v]: e }, "supportsDualStack"] }] }, p = [j], q = [k], r = [m];
-const _data = { version: "1.0", parameters: { Region: g, UseDualStack: h, UseFIPS: h, Endpoint: g }, rules: [{ conditions: [{ [t]: a, [u]: [i] }], type: b, rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: i, properties: l, headers: l }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [t]: a, [u]: r }], type: b, rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: e }], type: b, rules: [{ conditions: [j, k], type: b, rules: [{ conditions: [n, o], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://api.iotwireless-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: p, type: b, rules: [{ conditions: [n], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://api.iotwireless-fips.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: q, type: b, rules: [{ conditions: [o], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://api.iotwireless.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ conditions: [{ [t]: f, [u]: [m, "ap-northeast-1"] }], endpoint: { url: "https://api.iotwireless.ap-northeast-1.amazonaws.com", properties: l, headers: l }, type: d }, { conditions: [{ [t]: f, [u]: [m, "ap-southeast-2"] }], endpoint: { url: "https://api.iotwireless.ap-southeast-2.amazonaws.com", properties: l, headers: l }, type: d }, { conditions: [{ [t]: f, [u]: [m, "eu-west-1"] }], endpoint: { url: "https://api.iotwireless.eu-west-1.amazonaws.com", properties: l, headers: l }, type: d }, { conditions: [{ [t]: f, [u]: [m, "us-east-1"] }], endpoint: { url: "https://api.iotwireless.us-east-1.amazonaws.com", properties: l, headers: l }, type: d }, { conditions: [{ [t]: f, [u]: [m, "us-west-2"] }], endpoint: { url: "https://api.iotwireless.us-west-2.amazonaws.com", properties: l, headers: l }, type: d }, { endpoint: { url: "https://api.iotwireless.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://api.iotwireless-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://api.iotwireless-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://api.iotwireless.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://api.iotwireless.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;