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

package/dist-es/protocols/Aws_restJson1.js

@@ -205,6 +205,9 @@ export const serializeAws_restJson1CreateDeviceProfileCommand = async (input, co
         ClientRequestToken: input.ClientRequestToken ?? generateIdempotencyToken(),
         ...(input.LoRaWAN != null && { LoRaWAN: serializeAws_restJson1LoRaWANDeviceProfile(input.LoRaWAN, context) }),
         ...(input.Name != null && { Name: input.Name }),
+        ...(input.Sidewalk != null && {
+            Sidewalk: serializeAws_restJson1SidewalkCreateDeviceProfile(input.Sidewalk, context),
+        }),
         ...(input.Tags != null && { Tags: serializeAws_restJson1TagList(input.Tags, context) }),
     });
     return new __HttpRequest({
@@ -339,6 +342,9 @@ export const serializeAws_restJson1CreateWirelessDeviceCommand = async (input, c
         ...(input.LoRaWAN != null && { LoRaWAN: serializeAws_restJson1LoRaWANDevice(input.LoRaWAN, context) }),
         ...(input.Name != null && { Name: input.Name }),
         ...(input.Positioning != null && { Positioning: input.Positioning }),
+        ...(input.Sidewalk != null && {
+            Sidewalk: serializeAws_restJson1SidewalkCreateWirelessDevice(input.Sidewalk, context),
+        }),
         ...(input.Tags != null && { Tags: serializeAws_restJson1TagList(input.Tags, context) }),
         ...(input.Type != null && { Type: input.Type }),
     });
@@ -559,6 +565,22 @@ export const serializeAws_restJson1DeleteWirelessDeviceCommand = async (input, c
         body,
     });
 };
+export const serializeAws_restJson1DeleteWirelessDeviceImportTaskCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task/{Id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1DeleteWirelessGatewayCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -607,6 +629,26 @@ export const serializeAws_restJson1DeleteWirelessGatewayTaskDefinitionCommand =
         body,
     });
 };
+export const serializeAws_restJson1DeregisterWirelessDeviceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless-devices/{Identifier}/deregister";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
+    const query = map({
+        WirelessDeviceType: [, input.WirelessDeviceType],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const serializeAws_restJson1DisassociateAwsAccountFromPartnerAccountCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -1065,6 +1107,22 @@ export const serializeAws_restJson1GetWirelessDeviceCommand = async (input, cont
         body,
     });
 };
+export const serializeAws_restJson1GetWirelessDeviceImportTaskCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task/{Id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1GetWirelessDeviceStatisticsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -1211,6 +1269,29 @@ export const serializeAws_restJson1ListDeviceProfilesCommand = async (input, con
     const query = map({
         nextToken: [, input.NextToken],
         maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        deviceProfileType: [, input.DeviceProfileType],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task";
+    const query = map({
+        id: [, __expectNonNull(input.Id, `Id`)],
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        nextToken: [, input.NextToken],
+        status: [, input.Status],
     });
     let body;
     return new __HttpRequest({
@@ -1428,6 +1509,26 @@ export const serializeAws_restJson1ListTagsForResourceCommand = async (input, co
         body,
     });
 };
+export const serializeAws_restJson1ListWirelessDeviceImportTasksCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_tasks";
+    const query = map({
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        nextToken: [, input.NextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const serializeAws_restJson1ListWirelessDevicesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -1722,6 +1823,55 @@ export const serializeAws_restJson1StartMulticastGroupSessionCommand = async (in
         body,
     });
 };
+export const serializeAws_restJson1StartSingleWirelessDeviceImportTaskCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_single_device_import_task";
+    let body;
+    body = JSON.stringify({
+        ClientRequestToken: input.ClientRequestToken ?? generateIdempotencyToken(),
+        ...(input.DestinationName != null && { DestinationName: input.DestinationName }),
+        ...(input.DeviceName != null && { DeviceName: input.DeviceName }),
+        ...(input.Sidewalk != null && {
+            Sidewalk: serializeAws_restJson1SidewalkSingleStartImportInfo(input.Sidewalk, context),
+        }),
+        ...(input.Tags != null && { Tags: serializeAws_restJson1TagList(input.Tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1StartWirelessDeviceImportTaskCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task";
+    let body;
+    body = JSON.stringify({
+        ClientRequestToken: input.ClientRequestToken ?? generateIdempotencyToken(),
+        ...(input.DestinationName != null && { DestinationName: input.DestinationName }),
+        ...(input.Sidewalk != null && { Sidewalk: serializeAws_restJson1SidewalkStartImportInfo(input.Sidewalk, context) }),
+        ...(input.Tags != null && { Tags: serializeAws_restJson1TagList(input.Tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -2093,6 +2243,29 @@ export const serializeAws_restJson1UpdateWirelessDeviceCommand = async (input, c
         body,
     });
 };
+export const serializeAws_restJson1UpdateWirelessDeviceImportTaskCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/wireless_device_import_task/{Id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Id", () => input.Id, "{Id}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.Sidewalk != null && {
+            Sidewalk: serializeAws_restJson1SidewalkUpdateImportInfo(input.Sidewalk, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1UpdateWirelessGatewayCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -3342,6 +3515,51 @@ const deserializeAws_restJson1DeleteWirelessDeviceCommandError = async (output,
             });
     }
 };
+export const deserializeAws_restJson1DeleteWirelessDeviceImportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteWirelessDeviceImportTaskCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteWirelessDeviceImportTaskCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iotwireless#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.iotwireless#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1DeleteWirelessGatewayCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteWirelessGatewayCommandError(output, context);
@@ -3468,6 +3686,45 @@ const deserializeAws_restJson1DeleteWirelessGatewayTaskDefinitionCommandError =
             });
     }
 };
+export const deserializeAws_restJson1DeregisterWirelessDeviceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeregisterWirelessDeviceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeregisterWirelessDeviceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1DisassociateAwsAccountFromPartnerAccountCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return deserializeAws_restJson1DisassociateAwsAccountFromPartnerAccountCommandError(output, context);
@@ -3848,6 +4105,9 @@ export const deserializeAws_restJson1GetDeviceProfileCommand = async (output, co
     if (data.Name != null) {
         contents.Name = __expectString(data.Name);
     }
+    if (data.Sidewalk != null) {
+        contents.Sidewalk = deserializeAws_restJson1SidewalkGetDeviceProfile(data.Sidewalk, context);
+    }
     return contents;
 };
 const deserializeAws_restJson1GetDeviceProfileCommandError = async (output, context) => {
@@ -4748,29 +5008,107 @@ const deserializeAws_restJson1GetWirelessDeviceCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_restJson1GetWirelessDeviceStatisticsCommand = async (output, context) => {
+export const deserializeAws_restJson1GetWirelessDeviceImportTaskCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetWirelessDeviceStatisticsCommandError(output, context);
+        return deserializeAws_restJson1GetWirelessDeviceImportTaskCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.LastUplinkReceivedAt != null) {
-        contents.LastUplinkReceivedAt = __expectString(data.LastUplinkReceivedAt);
+    if (data.Arn != null) {
+        contents.Arn = __expectString(data.Arn);
     }
-    if (data.LoRaWAN != null) {
-        contents.LoRaWAN = deserializeAws_restJson1LoRaWANDeviceMetadata(data.LoRaWAN, context);
+    if (data.CreationTime != null) {
+        contents.CreationTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.CreationTime));
+    }
+    if (data.DestinationName != null) {
+        contents.DestinationName = __expectString(data.DestinationName);
+    }
+    if (data.FailedImportedDeviceCount != null) {
+        contents.FailedImportedDeviceCount = __expectLong(data.FailedImportedDeviceCount);
+    }
+    if (data.Id != null) {
+        contents.Id = __expectString(data.Id);
+    }
+    if (data.InitializedImportedDeviceCount != null) {
+        contents.InitializedImportedDeviceCount = __expectLong(data.InitializedImportedDeviceCount);
+    }
+    if (data.OnboardedImportedDeviceCount != null) {
+        contents.OnboardedImportedDeviceCount = __expectLong(data.OnboardedImportedDeviceCount);
+    }
+    if (data.PendingImportedDeviceCount != null) {
+        contents.PendingImportedDeviceCount = __expectLong(data.PendingImportedDeviceCount);
     }
     if (data.Sidewalk != null) {
-        contents.Sidewalk = deserializeAws_restJson1SidewalkDeviceMetadata(data.Sidewalk, context);
+        contents.Sidewalk = deserializeAws_restJson1SidewalkGetStartImportInfo(data.Sidewalk, context);
     }
-    if (data.WirelessDeviceId != null) {
-        contents.WirelessDeviceId = __expectString(data.WirelessDeviceId);
+    if (data.Status != null) {
+        contents.Status = __expectString(data.Status);
+    }
+    if (data.StatusReason != null) {
+        contents.StatusReason = __expectString(data.StatusReason);
     }
     return contents;
 };
-const deserializeAws_restJson1GetWirelessDeviceStatisticsCommandError = async (output, context) => {
+const deserializeAws_restJson1GetWirelessDeviceImportTaskCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iotwireless#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.iotwireless#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetWirelessDeviceStatisticsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetWirelessDeviceStatisticsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.LastUplinkReceivedAt != null) {
+        contents.LastUplinkReceivedAt = __expectString(data.LastUplinkReceivedAt);
+    }
+    if (data.LoRaWAN != null) {
+        contents.LoRaWAN = deserializeAws_restJson1LoRaWANDeviceMetadata(data.LoRaWAN, context);
+    }
+    if (data.Sidewalk != null) {
+        contents.Sidewalk = deserializeAws_restJson1SidewalkDeviceMetadata(data.Sidewalk, context);
+    }
+    if (data.WirelessDeviceId != null) {
+        contents.WirelessDeviceId = __expectString(data.WirelessDeviceId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetWirelessDeviceStatisticsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -5210,6 +5548,60 @@ const deserializeAws_restJson1ListDeviceProfilesCommandError = async (output, co
             });
     }
 };
+export const deserializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.DestinationName != null) {
+        contents.DestinationName = __expectString(data.DestinationName);
+    }
+    if (data.ImportedWirelessDeviceList != null) {
+        contents.ImportedWirelessDeviceList = deserializeAws_restJson1ImportedWirelessDeviceList(data.ImportedWirelessDeviceList, context);
+    }
+    if (data.NextToken != null) {
+        contents.NextToken = __expectString(data.NextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListDevicesForWirelessDeviceImportTaskCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iotwireless#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.iotwireless#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1ListEventConfigurationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListEventConfigurationsCommandError(output, context);
@@ -5666,6 +6058,57 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
+export const deserializeAws_restJson1ListWirelessDeviceImportTasksCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListWirelessDeviceImportTasksCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.NextToken != null) {
+        contents.NextToken = __expectString(data.NextToken);
+    }
+    if (data.WirelessDeviceImportTaskList != null) {
+        contents.WirelessDeviceImportTaskList = deserializeAws_restJson1WirelessDeviceImportTaskList(data.WirelessDeviceImportTaskList, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListWirelessDeviceImportTasksCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iotwireless#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.iotwireless#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1ListWirelessDevicesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListWirelessDevicesCommandError(output, context);
@@ -6233,6 +6676,108 @@ const deserializeAws_restJson1StartMulticastGroupSessionCommandError = async (ou
             });
     }
 };
+export const deserializeAws_restJson1StartSingleWirelessDeviceImportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1StartSingleWirelessDeviceImportTaskCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = __expectString(data.Arn);
+    }
+    if (data.Id != null) {
+        contents.Id = __expectString(data.Id);
+    }
+    return contents;
+};
+const deserializeAws_restJson1StartSingleWirelessDeviceImportTaskCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iotwireless#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.iotwireless#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1StartWirelessDeviceImportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1StartWirelessDeviceImportTaskCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = __expectString(data.Arn);
+    }
+    if (data.Id != null) {
+        contents.Id = __expectString(data.Id);
+    }
+    return contents;
+};
+const deserializeAws_restJson1StartWirelessDeviceImportTaskCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iotwireless#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.iotwireless#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return deserializeAws_restJson1TagResourceCommandError(output, context);
@@ -6830,6 +7375,51 @@ const deserializeAws_restJson1UpdateWirelessDeviceCommandError = async (output,
             });
     }
 };
+export const deserializeAws_restJson1UpdateWirelessDeviceImportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateWirelessDeviceImportTaskCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1UpdateWirelessDeviceImportTaskCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iotwireless#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.iotwireless#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.iotwireless#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iotwireless#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.iotwireless#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.iotwireless#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1UpdateWirelessGatewayCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return deserializeAws_restJson1UpdateWirelessGatewayCommandError(output, context);
@@ -7531,6 +8121,14 @@ const serializeAws_restJson1SidewalkAccountInfo = (input, context) => {
         ...(input.AppServerPrivateKey != null && { AppServerPrivateKey: input.AppServerPrivateKey }),
     };
 };
+const serializeAws_restJson1SidewalkCreateDeviceProfile = (input, context) => {
+    return {};
+};
+const serializeAws_restJson1SidewalkCreateWirelessDevice = (input, context) => {
+    return {
+        ...(input.DeviceProfileId != null && { DeviceProfileId: input.DeviceProfileId }),
+    };
+};
 const serializeAws_restJson1SidewalkEventNotificationConfigurations = (input, context) => {
     return {
         ...(input.AmazonIdEventTopic != null && { AmazonIdEventTopic: input.AmazonIdEventTopic }),
@@ -7548,11 +8146,27 @@ const serializeAws_restJson1SidewalkSendDataToDevice = (input, context) => {
         ...(input.Seq != null && { Seq: input.Seq }),
     };
 };
+const serializeAws_restJson1SidewalkSingleStartImportInfo = (input, context) => {
+    return {
+        ...(input.SidewalkManufacturingSn != null && { SidewalkManufacturingSn: input.SidewalkManufacturingSn }),
+    };
+};
+const serializeAws_restJson1SidewalkStartImportInfo = (input, context) => {
+    return {
+        ...(input.DeviceCreationFile != null && { DeviceCreationFile: input.DeviceCreationFile }),
+        ...(input.Role != null && { Role: input.Role }),
+    };
+};
 const serializeAws_restJson1SidewalkUpdateAccount = (input, context) => {
     return {
         ...(input.AppServerPrivateKey != null && { AppServerPrivateKey: input.AppServerPrivateKey }),
     };
 };
+const serializeAws_restJson1SidewalkUpdateImportInfo = (input, context) => {
+    return {
+        ...(input.DeviceCreationFile != null && { DeviceCreationFile: input.DeviceCreationFile }),
+    };
+};
 const serializeAws_restJson1SubBands = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -7866,6 +8480,26 @@ const deserializeAws_restJson1ConnectionStatusResourceTypeEventConfiguration = (
             : undefined,
     };
 };
+const deserializeAws_restJson1DakCertificateMetadata = (output, context) => {
+    return {
+        ApId: __expectString(output.ApId),
+        CertificateId: __expectString(output.CertificateId),
+        DeviceTypeId: __expectString(output.DeviceTypeId),
+        FactorySupport: __expectBoolean(output.FactorySupport),
+        MaxAllowedSignature: __expectInt32(output.MaxAllowedSignature),
+    };
+};
+const deserializeAws_restJson1DakCertificateMetadataList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1DakCertificateMetadata(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1DestinationList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -7898,6 +8532,17 @@ const deserializeAws_restJson1DeviceCertificateList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1DeviceCreationFileList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1DeviceProfile = (output, context) => {
     return {
         Arn: __expectString(output.Arn),
@@ -8043,6 +8688,32 @@ const deserializeAws_restJson1GatewayListItem = (output, context) => {
         GatewayId: __expectString(output.GatewayId),
     };
 };
+const deserializeAws_restJson1ImportedSidewalkDevice = (output, context) => {
+    return {
+        LastUpdateTime: output.LastUpdateTime != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.LastUpdateTime))
+            : undefined,
+        OnboardingStatus: __expectString(output.OnboardingStatus),
+        OnboardingStatusReason: __expectString(output.OnboardingStatusReason),
+        SidewalkManufacturingSn: __expectString(output.SidewalkManufacturingSn),
+    };
+};
+const deserializeAws_restJson1ImportedWirelessDevice = (output, context) => {
+    return {
+        Sidewalk: output.Sidewalk != null ? deserializeAws_restJson1ImportedSidewalkDevice(output.Sidewalk, context) : undefined,
+    };
+};
+const deserializeAws_restJson1ImportedWirelessDeviceList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ImportedWirelessDevice(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1JoinEuiFilters = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -8415,6 +9086,17 @@ const deserializeAws_restJson1PositionSolverDetails = (output, context) => {
         SemtechGnss: output.SemtechGnss != null ? deserializeAws_restJson1SemtechGnssDetail(output.SemtechGnss, context) : undefined,
     };
 };
+const deserializeAws_restJson1PrivateKeysList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1CertificateList(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1ProximityEventConfiguration = (output, context) => {
     return {
         Sidewalk: output.Sidewalk != null
@@ -8497,11 +9179,15 @@ const deserializeAws_restJson1SidewalkAccountList = (output, context) => {
 const deserializeAws_restJson1SidewalkDevice = (output, context) => {
     return {
         AmazonId: __expectString(output.AmazonId),
+        CertificateId: __expectString(output.CertificateId),
         DeviceCertificates: output.DeviceCertificates != null
             ? deserializeAws_restJson1DeviceCertificateList(output.DeviceCertificates, context)
             : undefined,
+        DeviceProfileId: __expectString(output.DeviceProfileId),
+        PrivateKeys: output.PrivateKeys != null ? deserializeAws_restJson1PrivateKeysList(output.PrivateKeys, context) : undefined,
         SidewalkId: __expectString(output.SidewalkId),
         SidewalkManufacturingSn: __expectString(output.SidewalkManufacturingSn),
+        Status: __expectString(output.Status),
     };
 };
 const deserializeAws_restJson1SidewalkDeviceMetadata = (output, context) => {
@@ -8517,14 +9203,33 @@ const deserializeAws_restJson1SidewalkEventNotificationConfigurations = (output,
         AmazonIdEventTopic: __expectString(output.AmazonIdEventTopic),
     };
 };
+const deserializeAws_restJson1SidewalkGetDeviceProfile = (output, context) => {
+    return {
+        ApplicationServerPublicKey: __expectString(output.ApplicationServerPublicKey),
+        DakCertificateMetadata: output.DakCertificateMetadata != null
+            ? deserializeAws_restJson1DakCertificateMetadataList(output.DakCertificateMetadata, context)
+            : undefined,
+        QualificationStatus: __expectBoolean(output.QualificationStatus),
+    };
+};
+const deserializeAws_restJson1SidewalkGetStartImportInfo = (output, context) => {
+    return {
+        DeviceCreationFileList: output.DeviceCreationFileList != null
+            ? deserializeAws_restJson1DeviceCreationFileList(output.DeviceCreationFileList, context)
+            : undefined,
+        Role: __expectString(output.Role),
+    };
+};
 const deserializeAws_restJson1SidewalkListDevice = (output, context) => {
     return {
         AmazonId: __expectString(output.AmazonId),
         DeviceCertificates: output.DeviceCertificates != null
             ? deserializeAws_restJson1DeviceCertificateList(output.DeviceCertificates, context)
             : undefined,
+        DeviceProfileId: __expectString(output.DeviceProfileId),
         SidewalkId: __expectString(output.SidewalkId),
         SidewalkManufacturingSn: __expectString(output.SidewalkManufacturingSn),
+        Status: __expectString(output.Status),
     };
 };
 const deserializeAws_restJson1SidewalkResourceTypeEventConfiguration = (output, context) => {
@@ -8601,6 +9306,34 @@ const deserializeAws_restJson1WirelessDeviceEventLogOptionList = (output, contex
     });
     return retVal;
 };
+const deserializeAws_restJson1WirelessDeviceImportTask = (output, context) => {
+    return {
+        Arn: __expectString(output.Arn),
+        CreationTime: output.CreationTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.CreationTime)) : undefined,
+        DestinationName: __expectString(output.DestinationName),
+        FailedImportedDeviceCount: __expectLong(output.FailedImportedDeviceCount),
+        Id: __expectString(output.Id),
+        InitializedImportedDeviceCount: __expectLong(output.InitializedImportedDeviceCount),
+        OnboardedImportedDeviceCount: __expectLong(output.OnboardedImportedDeviceCount),
+        PendingImportedDeviceCount: __expectLong(output.PendingImportedDeviceCount),
+        Sidewalk: output.Sidewalk != null
+            ? deserializeAws_restJson1SidewalkGetStartImportInfo(output.Sidewalk, context)
+            : undefined,
+        Status: __expectString(output.Status),
+        StatusReason: __expectString(output.StatusReason),
+    };
+};
+const deserializeAws_restJson1WirelessDeviceImportTaskList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1WirelessDeviceImportTask(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1WirelessDeviceList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)