@aws-sdk/client-iottwinmaker 3.44.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -0,0 +1,4460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeAws_restJson1UpdateEntityCommand = exports.deserializeAws_restJson1UpdateComponentTypeCommand = exports.deserializeAws_restJson1UntagResourceCommand = exports.deserializeAws_restJson1TagResourceCommand = exports.deserializeAws_restJson1ListWorkspacesCommand = exports.deserializeAws_restJson1ListTagsForResourceCommand = exports.deserializeAws_restJson1ListScenesCommand = exports.deserializeAws_restJson1ListEntitiesCommand = exports.deserializeAws_restJson1ListComponentTypesCommand = exports.deserializeAws_restJson1GetWorkspaceCommand = exports.deserializeAws_restJson1GetSceneCommand = exports.deserializeAws_restJson1GetPropertyValueHistoryCommand = exports.deserializeAws_restJson1GetPropertyValueCommand = exports.deserializeAws_restJson1GetEntityCommand = exports.deserializeAws_restJson1GetComponentTypeCommand = exports.deserializeAws_restJson1DeleteWorkspaceCommand = exports.deserializeAws_restJson1DeleteSceneCommand = exports.deserializeAws_restJson1DeleteEntityCommand = exports.deserializeAws_restJson1DeleteComponentTypeCommand = exports.deserializeAws_restJson1CreateWorkspaceCommand = exports.deserializeAws_restJson1CreateSceneCommand = exports.deserializeAws_restJson1CreateEntityCommand = exports.deserializeAws_restJson1CreateComponentTypeCommand = exports.deserializeAws_restJson1BatchPutPropertyValuesCommand = exports.serializeAws_restJson1UpdateWorkspaceCommand = exports.serializeAws_restJson1UpdateSceneCommand = exports.serializeAws_restJson1UpdateEntityCommand = exports.serializeAws_restJson1UpdateComponentTypeCommand = exports.serializeAws_restJson1UntagResourceCommand = exports.serializeAws_restJson1TagResourceCommand = exports.serializeAws_restJson1ListWorkspacesCommand = exports.serializeAws_restJson1ListTagsForResourceCommand = exports.serializeAws_restJson1ListScenesCommand = exports.serializeAws_restJson1ListEntitiesCommand = exports.serializeAws_restJson1ListComponentTypesCommand = exports.serializeAws_restJson1GetWorkspaceCommand = exports.serializeAws_restJson1GetSceneCommand = exports.serializeAws_restJson1GetPropertyValueHistoryCommand = exports.serializeAws_restJson1GetPropertyValueCommand = exports.serializeAws_restJson1GetEntityCommand = exports.serializeAws_restJson1GetComponentTypeCommand = exports.serializeAws_restJson1DeleteWorkspaceCommand = exports.serializeAws_restJson1DeleteSceneCommand = exports.serializeAws_restJson1DeleteEntityCommand = exports.serializeAws_restJson1DeleteComponentTypeCommand = exports.serializeAws_restJson1CreateWorkspaceCommand = exports.serializeAws_restJson1CreateSceneCommand = exports.serializeAws_restJson1CreateEntityCommand = exports.serializeAws_restJson1CreateComponentTypeCommand = exports.serializeAws_restJson1BatchPutPropertyValuesCommand = void 0;
+exports.deserializeAws_restJson1UpdateWorkspaceCommand = exports.deserializeAws_restJson1UpdateSceneCommand = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const serializeAws_restJson1BatchPutPropertyValuesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/entity-properties";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.entries !== undefined &&
+            input.entries !== null && { entries: serializeAws_restJson1Entries(input.entries, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "data." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1BatchPutPropertyValuesCommand = serializeAws_restJson1BatchPutPropertyValuesCommand;
+const serializeAws_restJson1CreateComponentTypeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/component-types/{componentTypeId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.componentTypeId !== undefined) {
+        const labelValue = input.componentTypeId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: componentTypeId.");
+        }
+        resolvedPath = resolvedPath.replace("{componentTypeId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: componentTypeId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.extendsFrom !== undefined &&
+            input.extendsFrom !== null && { extendsFrom: serializeAws_restJson1ExtendsFrom(input.extendsFrom, context) }),
+        ...(input.functions !== undefined &&
+            input.functions !== null && { functions: serializeAws_restJson1FunctionsRequest(input.functions, context) }),
+        ...(input.isSingleton !== undefined && input.isSingleton !== null && { isSingleton: input.isSingleton }),
+        ...(input.propertyDefinitions !== undefined &&
+            input.propertyDefinitions !== null && {
+            propertyDefinitions: serializeAws_restJson1PropertyDefinitionsRequest(input.propertyDefinitions, context),
+        }),
+        ...(input.tags !== undefined && input.tags !== null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateComponentTypeCommand = serializeAws_restJson1CreateComponentTypeCommand;
+const serializeAws_restJson1CreateEntityCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/entities";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.components !== undefined &&
+            input.components !== null && {
+            components: serializeAws_restJson1ComponentsMapRequest(input.components, context),
+        }),
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.entityId !== undefined && input.entityId !== null && { entityId: input.entityId }),
+        ...(input.entityName !== undefined && input.entityName !== null && { entityName: input.entityName }),
+        ...(input.parentEntityId !== undefined &&
+            input.parentEntityId !== null && { parentEntityId: input.parentEntityId }),
+        ...(input.tags !== undefined && input.tags !== null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateEntityCommand = serializeAws_restJson1CreateEntityCommand;
+const serializeAws_restJson1CreateSceneCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/scenes";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.capabilities !== undefined &&
+            input.capabilities !== null && {
+            capabilities: serializeAws_restJson1SceneCapabilities(input.capabilities, context),
+        }),
+        ...(input.contentLocation !== undefined &&
+            input.contentLocation !== null && { contentLocation: input.contentLocation }),
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.sceneId !== undefined && input.sceneId !== null && { sceneId: input.sceneId }),
+        ...(input.tags !== undefined && input.tags !== null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateSceneCommand = serializeAws_restJson1CreateSceneCommand;
+const serializeAws_restJson1CreateWorkspaceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.role !== undefined && input.role !== null && { role: input.role }),
+        ...(input.s3Location !== undefined && input.s3Location !== null && { s3Location: input.s3Location }),
+        ...(input.tags !== undefined && input.tags !== null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateWorkspaceCommand = serializeAws_restJson1CreateWorkspaceCommand;
+const serializeAws_restJson1DeleteComponentTypeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/component-types/{componentTypeId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.componentTypeId !== undefined) {
+        const labelValue = input.componentTypeId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: componentTypeId.");
+        }
+        resolvedPath = resolvedPath.replace("{componentTypeId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: componentTypeId.");
+    }
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteComponentTypeCommand = serializeAws_restJson1DeleteComponentTypeCommand;
+const serializeAws_restJson1DeleteEntityCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/entities/{entityId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.entityId !== undefined) {
+        const labelValue = input.entityId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: entityId.");
+        }
+        resolvedPath = resolvedPath.replace("{entityId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: entityId.");
+    }
+    const query = {
+        ...(input.isRecursive !== undefined && { isRecursive: input.isRecursive.toString() }),
+    };
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteEntityCommand = serializeAws_restJson1DeleteEntityCommand;
+const serializeAws_restJson1DeleteSceneCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/scenes/{sceneId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.sceneId !== undefined) {
+        const labelValue = input.sceneId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: sceneId.");
+        }
+        resolvedPath = resolvedPath.replace("{sceneId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: sceneId.");
+    }
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteSceneCommand = serializeAws_restJson1DeleteSceneCommand;
+const serializeAws_restJson1DeleteWorkspaceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteWorkspaceCommand = serializeAws_restJson1DeleteWorkspaceCommand;
+const serializeAws_restJson1GetComponentTypeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/component-types/{componentTypeId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.componentTypeId !== undefined) {
+        const labelValue = input.componentTypeId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: componentTypeId.");
+        }
+        resolvedPath = resolvedPath.replace("{componentTypeId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: componentTypeId.");
+    }
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetComponentTypeCommand = serializeAws_restJson1GetComponentTypeCommand;
+const serializeAws_restJson1GetEntityCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/entities/{entityId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.entityId !== undefined) {
+        const labelValue = input.entityId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: entityId.");
+        }
+        resolvedPath = resolvedPath.replace("{entityId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: entityId.");
+    }
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetEntityCommand = serializeAws_restJson1GetEntityCommand;
+const serializeAws_restJson1GetPropertyValueCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/entity-properties/value";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.componentName !== undefined && input.componentName !== null && { componentName: input.componentName }),
+        ...(input.componentTypeId !== undefined &&
+            input.componentTypeId !== null && { componentTypeId: input.componentTypeId }),
+        ...(input.entityId !== undefined && input.entityId !== null && { entityId: input.entityId }),
+        ...(input.selectedProperties !== undefined &&
+            input.selectedProperties !== null && {
+            selectedProperties: serializeAws_restJson1SelectedPropertyList(input.selectedProperties, context),
+        }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "data." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetPropertyValueCommand = serializeAws_restJson1GetPropertyValueCommand;
+const serializeAws_restJson1GetPropertyValueHistoryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/entity-properties/history";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.componentName !== undefined && input.componentName !== null && { componentName: input.componentName }),
+        ...(input.componentTypeId !== undefined &&
+            input.componentTypeId !== null && { componentTypeId: input.componentTypeId }),
+        ...(input.endDateTime !== undefined &&
+            input.endDateTime !== null && { endDateTime: Math.round(input.endDateTime.getTime() / 1000) }),
+        ...(input.entityId !== undefined && input.entityId !== null && { entityId: input.entityId }),
+        ...(input.interpolation !== undefined &&
+            input.interpolation !== null && {
+            interpolation: serializeAws_restJson1InterpolationParameters(input.interpolation, context),
+        }),
+        ...(input.maxResults !== undefined && input.maxResults !== null && { maxResults: input.maxResults }),
+        ...(input.nextToken !== undefined && input.nextToken !== null && { nextToken: input.nextToken }),
+        ...(input.orderByTime !== undefined && input.orderByTime !== null && { orderByTime: input.orderByTime }),
+        ...(input.propertyFilters !== undefined &&
+            input.propertyFilters !== null && {
+            propertyFilters: serializeAws_restJson1PropertyFilters(input.propertyFilters, context),
+        }),
+        ...(input.selectedProperties !== undefined &&
+            input.selectedProperties !== null && {
+            selectedProperties: serializeAws_restJson1SelectedPropertyList(input.selectedProperties, context),
+        }),
+        ...(input.startDateTime !== undefined &&
+            input.startDateTime !== null && { startDateTime: Math.round(input.startDateTime.getTime() / 1000) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "data." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetPropertyValueHistoryCommand = serializeAws_restJson1GetPropertyValueHistoryCommand;
+const serializeAws_restJson1GetSceneCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/scenes/{sceneId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.sceneId !== undefined) {
+        const labelValue = input.sceneId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: sceneId.");
+        }
+        resolvedPath = resolvedPath.replace("{sceneId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: sceneId.");
+    }
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetSceneCommand = serializeAws_restJson1GetSceneCommand;
+const serializeAws_restJson1GetWorkspaceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetWorkspaceCommand = serializeAws_restJson1GetWorkspaceCommand;
+const serializeAws_restJson1ListComponentTypesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/component-types-list";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.filters !== undefined &&
+            input.filters !== null && { filters: serializeAws_restJson1ListComponentTypesFilters(input.filters, context) }),
+        ...(input.maxResults !== undefined && input.maxResults !== null && { maxResults: input.maxResults }),
+        ...(input.nextToken !== undefined && input.nextToken !== null && { nextToken: input.nextToken }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListComponentTypesCommand = serializeAws_restJson1ListComponentTypesCommand;
+const serializeAws_restJson1ListEntitiesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/entities-list";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.filters !== undefined &&
+            input.filters !== null && { filters: serializeAws_restJson1ListEntitiesFilters(input.filters, context) }),
+        ...(input.maxResults !== undefined && input.maxResults !== null && { maxResults: input.maxResults }),
+        ...(input.nextToken !== undefined && input.nextToken !== null && { nextToken: input.nextToken }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListEntitiesCommand = serializeAws_restJson1ListEntitiesCommand;
+const serializeAws_restJson1ListScenesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}/scenes-list";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.maxResults !== undefined && input.maxResults !== null && { maxResults: input.maxResults }),
+        ...(input.nextToken !== undefined && input.nextToken !== null && { nextToken: input.nextToken }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListScenesCommand = serializeAws_restJson1ListScenesCommand;
+const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/tags-list";
+    let body;
+    body = JSON.stringify({
+        ...(input.maxResults !== undefined && input.maxResults !== null && { maxResults: input.maxResults }),
+        ...(input.nextToken !== undefined && input.nextToken !== null && { nextToken: input.nextToken }),
+        ...(input.resourceARN !== undefined && input.resourceARN !== null && { resourceARN: input.resourceARN }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListTagsForResourceCommand = serializeAws_restJson1ListTagsForResourceCommand;
+const serializeAws_restJson1ListWorkspacesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces-list";
+    let body;
+    body = JSON.stringify({
+        ...(input.maxResults !== undefined && input.maxResults !== null && { maxResults: input.maxResults }),
+        ...(input.nextToken !== undefined && input.nextToken !== null && { nextToken: input.nextToken }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListWorkspacesCommand = serializeAws_restJson1ListWorkspacesCommand;
+const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    let body;
+    body = JSON.stringify({
+        ...(input.resourceARN !== undefined && input.resourceARN !== null && { resourceARN: input.resourceARN }),
+        ...(input.tags !== undefined && input.tags !== null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1TagResourceCommand = serializeAws_restJson1TagResourceCommand;
+const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    const query = {
+        ...(input.resourceARN !== undefined && { resourceARN: input.resourceARN }),
+        ...(input.tagKeys !== undefined && { tagKeys: (input.tagKeys || []).map((_entry) => _entry) }),
+    };
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1UntagResourceCommand = serializeAws_restJson1UntagResourceCommand;
+const serializeAws_restJson1UpdateComponentTypeCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/component-types/{componentTypeId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.componentTypeId !== undefined) {
+        const labelValue = input.componentTypeId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: componentTypeId.");
+        }
+        resolvedPath = resolvedPath.replace("{componentTypeId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: componentTypeId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.extendsFrom !== undefined &&
+            input.extendsFrom !== null && { extendsFrom: serializeAws_restJson1ExtendsFrom(input.extendsFrom, context) }),
+        ...(input.functions !== undefined &&
+            input.functions !== null && { functions: serializeAws_restJson1FunctionsRequest(input.functions, context) }),
+        ...(input.isSingleton !== undefined && input.isSingleton !== null && { isSingleton: input.isSingleton }),
+        ...(input.propertyDefinitions !== undefined &&
+            input.propertyDefinitions !== null && {
+            propertyDefinitions: serializeAws_restJson1PropertyDefinitionsRequest(input.propertyDefinitions, context),
+        }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateComponentTypeCommand = serializeAws_restJson1UpdateComponentTypeCommand;
+const serializeAws_restJson1UpdateEntityCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/entities/{entityId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.entityId !== undefined) {
+        const labelValue = input.entityId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: entityId.");
+        }
+        resolvedPath = resolvedPath.replace("{entityId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: entityId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.componentUpdates !== undefined &&
+            input.componentUpdates !== null && {
+            componentUpdates: serializeAws_restJson1ComponentUpdatesMapRequest(input.componentUpdates, context),
+        }),
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.entityName !== undefined && input.entityName !== null && { entityName: input.entityName }),
+        ...(input.parentEntityUpdate !== undefined &&
+            input.parentEntityUpdate !== null && {
+            parentEntityUpdate: serializeAws_restJson1ParentEntityUpdateRequest(input.parentEntityUpdate, context),
+        }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateEntityCommand = serializeAws_restJson1UpdateEntityCommand;
+const serializeAws_restJson1UpdateSceneCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` +
+        "/workspaces/{workspaceId}/scenes/{sceneId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    if (input.sceneId !== undefined) {
+        const labelValue = input.sceneId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: sceneId.");
+        }
+        resolvedPath = resolvedPath.replace("{sceneId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: sceneId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.capabilities !== undefined &&
+            input.capabilities !== null && {
+            capabilities: serializeAws_restJson1SceneCapabilities(input.capabilities, context),
+        }),
+        ...(input.contentLocation !== undefined &&
+            input.contentLocation !== null && { contentLocation: input.contentLocation }),
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateSceneCommand = serializeAws_restJson1UpdateSceneCommand;
+const serializeAws_restJson1UpdateWorkspaceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/workspaces/{workspaceId}";
+    if (input.workspaceId !== undefined) {
+        const labelValue = input.workspaceId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: workspaceId.");
+        }
+        resolvedPath = resolvedPath.replace("{workspaceId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: workspaceId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.role !== undefined && input.role !== null && { role: input.role }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "api." + resolvedHostname;
+        if (!protocol_http_1.isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateWorkspaceCommand = serializeAws_restJson1UpdateWorkspaceCommand;
+const deserializeAws_restJson1BatchPutPropertyValuesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1BatchPutPropertyValuesCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        errorEntries: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.errorEntries !== undefined && data.errorEntries !== null) {
+        contents.errorEntries = deserializeAws_restJson1ErrorEntries(data.errorEntries, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1BatchPutPropertyValuesCommand = deserializeAws_restJson1BatchPutPropertyValuesCommand;
+const deserializeAws_restJson1BatchPutPropertyValuesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1CreateComponentTypeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateComponentTypeCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        creationDateTime: undefined,
+        state: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    if (data.state !== undefined && data.state !== null) {
+        contents.state = smithy_client_1.expectString(data.state);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateComponentTypeCommand = deserializeAws_restJson1CreateComponentTypeCommand;
+const deserializeAws_restJson1CreateComponentTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.iottwinmaker#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1CreateEntityCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateEntityCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        creationDateTime: undefined,
+        entityId: undefined,
+        state: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    if (data.entityId !== undefined && data.entityId !== null) {
+        contents.entityId = smithy_client_1.expectString(data.entityId);
+    }
+    if (data.state !== undefined && data.state !== null) {
+        contents.state = smithy_client_1.expectString(data.state);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateEntityCommand = deserializeAws_restJson1CreateEntityCommand;
+const deserializeAws_restJson1CreateEntityCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.iottwinmaker#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1CreateSceneCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateSceneCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        creationDateTime: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateSceneCommand = deserializeAws_restJson1CreateSceneCommand;
+const deserializeAws_restJson1CreateSceneCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.iottwinmaker#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1CreateWorkspaceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateWorkspaceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        creationDateTime: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateWorkspaceCommand = deserializeAws_restJson1CreateWorkspaceCommand;
+const deserializeAws_restJson1CreateWorkspaceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.iottwinmaker#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1DeleteComponentTypeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteComponentTypeCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        state: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.state !== undefined && data.state !== null) {
+        contents.state = smithy_client_1.expectString(data.state);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1DeleteComponentTypeCommand = deserializeAws_restJson1DeleteComponentTypeCommand;
+const deserializeAws_restJson1DeleteComponentTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1DeleteEntityCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteEntityCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        state: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.state !== undefined && data.state !== null) {
+        contents.state = smithy_client_1.expectString(data.state);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1DeleteEntityCommand = deserializeAws_restJson1DeleteEntityCommand;
+const deserializeAws_restJson1DeleteEntityCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1DeleteSceneCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteSceneCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1DeleteSceneCommand = deserializeAws_restJson1DeleteSceneCommand;
+const deserializeAws_restJson1DeleteSceneCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1DeleteWorkspaceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteWorkspaceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1DeleteWorkspaceCommand = deserializeAws_restJson1DeleteWorkspaceCommand;
+const deserializeAws_restJson1DeleteWorkspaceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetComponentTypeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetComponentTypeCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        componentTypeId: undefined,
+        creationDateTime: undefined,
+        description: undefined,
+        extendsFrom: undefined,
+        functions: undefined,
+        isAbstract: undefined,
+        isSchemaInitialized: undefined,
+        isSingleton: undefined,
+        propertyDefinitions: undefined,
+        status: undefined,
+        updateDateTime: undefined,
+        workspaceId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.componentTypeId !== undefined && data.componentTypeId !== null) {
+        contents.componentTypeId = smithy_client_1.expectString(data.componentTypeId);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    if (data.description !== undefined && data.description !== null) {
+        contents.description = smithy_client_1.expectString(data.description);
+    }
+    if (data.extendsFrom !== undefined && data.extendsFrom !== null) {
+        contents.extendsFrom = deserializeAws_restJson1ExtendsFrom(data.extendsFrom, context);
+    }
+    if (data.functions !== undefined && data.functions !== null) {
+        contents.functions = deserializeAws_restJson1FunctionsResponse(data.functions, context);
+    }
+    if (data.isAbstract !== undefined && data.isAbstract !== null) {
+        contents.isAbstract = smithy_client_1.expectBoolean(data.isAbstract);
+    }
+    if (data.isSchemaInitialized !== undefined && data.isSchemaInitialized !== null) {
+        contents.isSchemaInitialized = smithy_client_1.expectBoolean(data.isSchemaInitialized);
+    }
+    if (data.isSingleton !== undefined && data.isSingleton !== null) {
+        contents.isSingleton = smithy_client_1.expectBoolean(data.isSingleton);
+    }
+    if (data.propertyDefinitions !== undefined && data.propertyDefinitions !== null) {
+        contents.propertyDefinitions = deserializeAws_restJson1PropertyDefinitionsResponse(data.propertyDefinitions, context);
+    }
+    if (data.status !== undefined && data.status !== null) {
+        contents.status = deserializeAws_restJson1Status(data.status, context);
+    }
+    if (data.updateDateTime !== undefined && data.updateDateTime !== null) {
+        contents.updateDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.updateDateTime)));
+    }
+    if (data.workspaceId !== undefined && data.workspaceId !== null) {
+        contents.workspaceId = smithy_client_1.expectString(data.workspaceId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetComponentTypeCommand = deserializeAws_restJson1GetComponentTypeCommand;
+const deserializeAws_restJson1GetComponentTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetEntityCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetEntityCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        components: undefined,
+        creationDateTime: undefined,
+        description: undefined,
+        entityId: undefined,
+        entityName: undefined,
+        hasChildEntities: undefined,
+        parentEntityId: undefined,
+        status: undefined,
+        updateDateTime: undefined,
+        workspaceId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.components !== undefined && data.components !== null) {
+        contents.components = deserializeAws_restJson1ComponentsMap(data.components, context);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    if (data.description !== undefined && data.description !== null) {
+        contents.description = smithy_client_1.expectString(data.description);
+    }
+    if (data.entityId !== undefined && data.entityId !== null) {
+        contents.entityId = smithy_client_1.expectString(data.entityId);
+    }
+    if (data.entityName !== undefined && data.entityName !== null) {
+        contents.entityName = smithy_client_1.expectString(data.entityName);
+    }
+    if (data.hasChildEntities !== undefined && data.hasChildEntities !== null) {
+        contents.hasChildEntities = smithy_client_1.expectBoolean(data.hasChildEntities);
+    }
+    if (data.parentEntityId !== undefined && data.parentEntityId !== null) {
+        contents.parentEntityId = smithy_client_1.expectString(data.parentEntityId);
+    }
+    if (data.status !== undefined && data.status !== null) {
+        contents.status = deserializeAws_restJson1Status(data.status, context);
+    }
+    if (data.updateDateTime !== undefined && data.updateDateTime !== null) {
+        contents.updateDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.updateDateTime)));
+    }
+    if (data.workspaceId !== undefined && data.workspaceId !== null) {
+        contents.workspaceId = smithy_client_1.expectString(data.workspaceId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetEntityCommand = deserializeAws_restJson1GetEntityCommand;
+const deserializeAws_restJson1GetEntityCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetPropertyValueCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetPropertyValueCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        propertyValues: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.propertyValues !== undefined && data.propertyValues !== null) {
+        contents.propertyValues = deserializeAws_restJson1PropertyLatestValueMap(data.propertyValues, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetPropertyValueCommand = deserializeAws_restJson1GetPropertyValueCommand;
+const deserializeAws_restJson1GetPropertyValueCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConnectorFailureException":
+        case "com.amazonaws.iottwinmaker#ConnectorFailureException":
+            response = {
+                ...(await deserializeAws_restJson1ConnectorFailureExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConnectorTimeoutException":
+        case "com.amazonaws.iottwinmaker#ConnectorTimeoutException":
+            response = {
+                ...(await deserializeAws_restJson1ConnectorTimeoutExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetPropertyValueHistoryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetPropertyValueHistoryCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        nextToken: undefined,
+        propertyValues: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    if (data.propertyValues !== undefined && data.propertyValues !== null) {
+        contents.propertyValues = deserializeAws_restJson1PropertyValueList(data.propertyValues, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetPropertyValueHistoryCommand = deserializeAws_restJson1GetPropertyValueHistoryCommand;
+const deserializeAws_restJson1GetPropertyValueHistoryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConnectorFailureException":
+        case "com.amazonaws.iottwinmaker#ConnectorFailureException":
+            response = {
+                ...(await deserializeAws_restJson1ConnectorFailureExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConnectorTimeoutException":
+        case "com.amazonaws.iottwinmaker#ConnectorTimeoutException":
+            response = {
+                ...(await deserializeAws_restJson1ConnectorTimeoutExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetSceneCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetSceneCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        capabilities: undefined,
+        contentLocation: undefined,
+        creationDateTime: undefined,
+        description: undefined,
+        sceneId: undefined,
+        updateDateTime: undefined,
+        workspaceId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.capabilities !== undefined && data.capabilities !== null) {
+        contents.capabilities = deserializeAws_restJson1SceneCapabilities(data.capabilities, context);
+    }
+    if (data.contentLocation !== undefined && data.contentLocation !== null) {
+        contents.contentLocation = smithy_client_1.expectString(data.contentLocation);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    if (data.description !== undefined && data.description !== null) {
+        contents.description = smithy_client_1.expectString(data.description);
+    }
+    if (data.sceneId !== undefined && data.sceneId !== null) {
+        contents.sceneId = smithy_client_1.expectString(data.sceneId);
+    }
+    if (data.updateDateTime !== undefined && data.updateDateTime !== null) {
+        contents.updateDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.updateDateTime)));
+    }
+    if (data.workspaceId !== undefined && data.workspaceId !== null) {
+        contents.workspaceId = smithy_client_1.expectString(data.workspaceId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetSceneCommand = deserializeAws_restJson1GetSceneCommand;
+const deserializeAws_restJson1GetSceneCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetWorkspaceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetWorkspaceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        creationDateTime: undefined,
+        description: undefined,
+        role: undefined,
+        s3Location: undefined,
+        updateDateTime: undefined,
+        workspaceId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.creationDateTime !== undefined && data.creationDateTime !== null) {
+        contents.creationDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.creationDateTime)));
+    }
+    if (data.description !== undefined && data.description !== null) {
+        contents.description = smithy_client_1.expectString(data.description);
+    }
+    if (data.role !== undefined && data.role !== null) {
+        contents.role = smithy_client_1.expectString(data.role);
+    }
+    if (data.s3Location !== undefined && data.s3Location !== null) {
+        contents.s3Location = smithy_client_1.expectString(data.s3Location);
+    }
+    if (data.updateDateTime !== undefined && data.updateDateTime !== null) {
+        contents.updateDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.updateDateTime)));
+    }
+    if (data.workspaceId !== undefined && data.workspaceId !== null) {
+        contents.workspaceId = smithy_client_1.expectString(data.workspaceId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetWorkspaceCommand = deserializeAws_restJson1GetWorkspaceCommand;
+const deserializeAws_restJson1GetWorkspaceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListComponentTypesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListComponentTypesCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        componentTypeSummaries: undefined,
+        maxResults: undefined,
+        nextToken: undefined,
+        workspaceId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.componentTypeSummaries !== undefined && data.componentTypeSummaries !== null) {
+        contents.componentTypeSummaries = deserializeAws_restJson1ComponentTypeSummaries(data.componentTypeSummaries, context);
+    }
+    if (data.maxResults !== undefined && data.maxResults !== null) {
+        contents.maxResults = smithy_client_1.expectInt32(data.maxResults);
+    }
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    if (data.workspaceId !== undefined && data.workspaceId !== null) {
+        contents.workspaceId = smithy_client_1.expectString(data.workspaceId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListComponentTypesCommand = deserializeAws_restJson1ListComponentTypesCommand;
+const deserializeAws_restJson1ListComponentTypesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListEntitiesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListEntitiesCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        entitySummaries: undefined,
+        nextToken: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.entitySummaries !== undefined && data.entitySummaries !== null) {
+        contents.entitySummaries = deserializeAws_restJson1EntitySummaries(data.entitySummaries, context);
+    }
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListEntitiesCommand = deserializeAws_restJson1ListEntitiesCommand;
+const deserializeAws_restJson1ListEntitiesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListScenesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListScenesCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        nextToken: undefined,
+        sceneSummaries: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    if (data.sceneSummaries !== undefined && data.sceneSummaries !== null) {
+        contents.sceneSummaries = deserializeAws_restJson1SceneSummaries(data.sceneSummaries, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListScenesCommand = deserializeAws_restJson1ListScenesCommand;
+const deserializeAws_restJson1ListScenesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        nextToken: undefined,
+        tags: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    if (data.tags !== undefined && data.tags !== null) {
+        contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListTagsForResourceCommand = deserializeAws_restJson1ListTagsForResourceCommand;
+const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListWorkspacesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListWorkspacesCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        nextToken: undefined,
+        workspaceSummaries: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.nextToken !== undefined && data.nextToken !== null) {
+        contents.nextToken = smithy_client_1.expectString(data.nextToken);
+    }
+    if (data.workspaceSummaries !== undefined && data.workspaceSummaries !== null) {
+        contents.workspaceSummaries = deserializeAws_restJson1WorkspaceSummaries(data.workspaceSummaries, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListWorkspacesCommand = deserializeAws_restJson1ListWorkspacesCommand;
+const deserializeAws_restJson1ListWorkspacesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1TagResourceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1TagResourceCommand = deserializeAws_restJson1TagResourceCommand;
+const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "TooManyTagsException":
+        case "com.amazonaws.iottwinmaker#TooManyTagsException":
+            response = {
+                ...(await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1UntagResourceCommand = deserializeAws_restJson1UntagResourceCommand;
+const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1UpdateComponentTypeCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateComponentTypeCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        arn: undefined,
+        componentTypeId: undefined,
+        state: undefined,
+        workspaceId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn !== undefined && data.arn !== null) {
+        contents.arn = smithy_client_1.expectString(data.arn);
+    }
+    if (data.componentTypeId !== undefined && data.componentTypeId !== null) {
+        contents.componentTypeId = smithy_client_1.expectString(data.componentTypeId);
+    }
+    if (data.state !== undefined && data.state !== null) {
+        contents.state = smithy_client_1.expectString(data.state);
+    }
+    if (data.workspaceId !== undefined && data.workspaceId !== null) {
+        contents.workspaceId = smithy_client_1.expectString(data.workspaceId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1UpdateComponentTypeCommand = deserializeAws_restJson1UpdateComponentTypeCommand;
+const deserializeAws_restJson1UpdateComponentTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1UpdateEntityCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateEntityCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        state: undefined,
+        updateDateTime: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.state !== undefined && data.state !== null) {
+        contents.state = smithy_client_1.expectString(data.state);
+    }
+    if (data.updateDateTime !== undefined && data.updateDateTime !== null) {
+        contents.updateDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.updateDateTime)));
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1UpdateEntityCommand = deserializeAws_restJson1UpdateEntityCommand;
+const deserializeAws_restJson1UpdateEntityCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.iottwinmaker#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1UpdateSceneCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateSceneCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        updateDateTime: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.updateDateTime !== undefined && data.updateDateTime !== null) {
+        contents.updateDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.updateDateTime)));
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1UpdateSceneCommand = deserializeAws_restJson1UpdateSceneCommand;
+const deserializeAws_restJson1UpdateSceneCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1UpdateWorkspaceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateWorkspaceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        updateDateTime: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.updateDateTime !== undefined && data.updateDateTime !== null) {
+        contents.updateDateTime = smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(data.updateDateTime)));
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1UpdateWorkspaceCommand = deserializeAws_restJson1UpdateWorkspaceCommand;
+const deserializeAws_restJson1UpdateWorkspaceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.iottwinmaker#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.iottwinmaker#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.iottwinmaker#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.iottwinmaker#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.iottwinmaker#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.iottwinmaker#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "AccessDeniedException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ConflictException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ConnectorFailureExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ConnectorFailureException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ConnectorTimeoutExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ConnectorTimeoutException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "InternalServerException",
+        $fault: "server",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ResourceNotFoundException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ServiceQuotaExceededException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ThrottlingException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "TooManyTagsException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "ValidationException",
+        $fault: "client",
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    return contents;
+};
+const serializeAws_restJson1ComponentRequest = (input, context) => {
+    return {
+        ...(input.componentTypeId !== undefined &&
+            input.componentTypeId !== null && { componentTypeId: input.componentTypeId }),
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.properties !== undefined &&
+            input.properties !== null && { properties: serializeAws_restJson1PropertyRequests(input.properties, context) }),
+    };
+};
+const serializeAws_restJson1ComponentsMapRequest = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: serializeAws_restJson1ComponentRequest(value, context),
+        };
+    }, {});
+};
+const serializeAws_restJson1ComponentUpdateRequest = (input, context) => {
+    return {
+        ...(input.componentTypeId !== undefined &&
+            input.componentTypeId !== null && { componentTypeId: input.componentTypeId }),
+        ...(input.description !== undefined && input.description !== null && { description: input.description }),
+        ...(input.propertyUpdates !== undefined &&
+            input.propertyUpdates !== null && {
+            propertyUpdates: serializeAws_restJson1PropertyRequests(input.propertyUpdates, context),
+        }),
+        ...(input.updateType !== undefined && input.updateType !== null && { updateType: input.updateType }),
+    };
+};
+const serializeAws_restJson1ComponentUpdatesMapRequest = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: serializeAws_restJson1ComponentUpdateRequest(value, context),
+        };
+    }, {});
+};
+const serializeAws_restJson1Configuration = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const serializeAws_restJson1DataConnector = (input, context) => {
+    return {
+        ...(input.isNative !== undefined && input.isNative !== null && { isNative: input.isNative }),
+        ...(input.lambda !== undefined &&
+            input.lambda !== null && { lambda: serializeAws_restJson1LambdaFunction(input.lambda, context) }),
+    };
+};
+const serializeAws_restJson1DataType = (input, context) => {
+    return {
+        ...(input.allowedValues !== undefined &&
+            input.allowedValues !== null && {
+            allowedValues: serializeAws_restJson1DataValueList(input.allowedValues, context),
+        }),
+        ...(input.nestedType !== undefined &&
+            input.nestedType !== null && { nestedType: serializeAws_restJson1DataType(input.nestedType, context) }),
+        ...(input.relationship !== undefined &&
+            input.relationship !== null && { relationship: serializeAws_restJson1Relationship(input.relationship, context) }),
+        ...(input.type !== undefined && input.type !== null && { type: input.type }),
+        ...(input.unitOfMeasure !== undefined && input.unitOfMeasure !== null && { unitOfMeasure: input.unitOfMeasure }),
+    };
+};
+const serializeAws_restJson1DataValue = (input, context) => {
+    return {
+        ...(input.booleanValue !== undefined && input.booleanValue !== null && { booleanValue: input.booleanValue }),
+        ...(input.doubleValue !== undefined &&
+            input.doubleValue !== null && { doubleValue: smithy_client_1.serializeFloat(input.doubleValue) }),
+        ...(input.expression !== undefined && input.expression !== null && { expression: input.expression }),
+        ...(input.integerValue !== undefined && input.integerValue !== null && { integerValue: input.integerValue }),
+        ...(input.listValue !== undefined &&
+            input.listValue !== null && { listValue: serializeAws_restJson1DataValueList(input.listValue, context) }),
+        ...(input.longValue !== undefined && input.longValue !== null && { longValue: input.longValue }),
+        ...(input.mapValue !== undefined &&
+            input.mapValue !== null && { mapValue: serializeAws_restJson1DataValueMap(input.mapValue, context) }),
+        ...(input.relationshipValue !== undefined &&
+            input.relationshipValue !== null && {
+            relationshipValue: serializeAws_restJson1RelationshipValue(input.relationshipValue, context),
+        }),
+        ...(input.stringValue !== undefined && input.stringValue !== null && { stringValue: input.stringValue }),
+    };
+};
+const serializeAws_restJson1DataValueList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1DataValue(entry, context);
+    });
+};
+const serializeAws_restJson1DataValueMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: serializeAws_restJson1DataValue(value, context),
+        };
+    }, {});
+};
+const serializeAws_restJson1EntityPropertyReference = (input, context) => {
+    return {
+        ...(input.componentName !== undefined && input.componentName !== null && { componentName: input.componentName }),
+        ...(input.entityId !== undefined && input.entityId !== null && { entityId: input.entityId }),
+        ...(input.externalIdProperty !== undefined &&
+            input.externalIdProperty !== null && {
+            externalIdProperty: serializeAws_restJson1ExternalIdProperty(input.externalIdProperty, context),
+        }),
+        ...(input.propertyName !== undefined && input.propertyName !== null && { propertyName: input.propertyName }),
+    };
+};
+const serializeAws_restJson1Entries = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1PropertyValueEntry(entry, context);
+    });
+};
+const serializeAws_restJson1ExtendsFrom = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1ExternalIdProperty = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const serializeAws_restJson1FunctionRequest = (input, context) => {
+    return {
+        ...(input.implementedBy !== undefined &&
+            input.implementedBy !== null && {
+            implementedBy: serializeAws_restJson1DataConnector(input.implementedBy, context),
+        }),
+        ...(input.requiredProperties !== undefined &&
+            input.requiredProperties !== null && {
+            requiredProperties: serializeAws_restJson1RequiredProperties(input.requiredProperties, context),
+        }),
+        ...(input.scope !== undefined && input.scope !== null && { scope: input.scope }),
+    };
+};
+const serializeAws_restJson1FunctionsRequest = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: serializeAws_restJson1FunctionRequest(value, context),
+        };
+    }, {});
+};
+const serializeAws_restJson1InterpolationParameters = (input, context) => {
+    return {
+        ...(input.interpolationType !== undefined &&
+            input.interpolationType !== null && { interpolationType: input.interpolationType }),
+        ...(input.intervalInSeconds !== undefined &&
+            input.intervalInSeconds !== null && { intervalInSeconds: input.intervalInSeconds }),
+    };
+};
+const serializeAws_restJson1LambdaFunction = (input, context) => {
+    return {
+        ...(input.arn !== undefined && input.arn !== null && { arn: input.arn }),
+    };
+};
+const serializeAws_restJson1ListComponentTypesFilter = (input, context) => {
+    return models_0_1.ListComponentTypesFilter.visit(input, {
+        extendsFrom: (value) => ({ extendsFrom: value }),
+        isAbstract: (value) => ({ isAbstract: value }),
+        namespace: (value) => ({ namespace: value }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1ListComponentTypesFilters = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1ListComponentTypesFilter(entry, context);
+    });
+};
+const serializeAws_restJson1ListEntitiesFilter = (input, context) => {
+    return models_0_1.ListEntitiesFilter.visit(input, {
+        componentTypeId: (value) => ({ componentTypeId: value }),
+        parentEntityId: (value) => ({ parentEntityId: value }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1ListEntitiesFilters = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1ListEntitiesFilter(entry, context);
+    });
+};
+const serializeAws_restJson1ParentEntityUpdateRequest = (input, context) => {
+    return {
+        ...(input.parentEntityId !== undefined &&
+            input.parentEntityId !== null && { parentEntityId: input.parentEntityId }),
+        ...(input.updateType !== undefined && input.updateType !== null && { updateType: input.updateType }),
+    };
+};
+const serializeAws_restJson1PropertyDefinitionRequest = (input, context) => {
+    return {
+        ...(input.configuration !== undefined &&
+            input.configuration !== null && {
+            configuration: serializeAws_restJson1Configuration(input.configuration, context),
+        }),
+        ...(input.dataType !== undefined &&
+            input.dataType !== null && { dataType: serializeAws_restJson1DataType(input.dataType, context) }),
+        ...(input.defaultValue !== undefined &&
+            input.defaultValue !== null && { defaultValue: serializeAws_restJson1DataValue(input.defaultValue, context) }),
+        ...(input.isExternalId !== undefined && input.isExternalId !== null && { isExternalId: input.isExternalId }),
+        ...(input.isRequiredInEntity !== undefined &&
+            input.isRequiredInEntity !== null && { isRequiredInEntity: input.isRequiredInEntity }),
+        ...(input.isStoredExternally !== undefined &&
+            input.isStoredExternally !== null && { isStoredExternally: input.isStoredExternally }),
+        ...(input.isTimeSeries !== undefined && input.isTimeSeries !== null && { isTimeSeries: input.isTimeSeries }),
+    };
+};
+const serializeAws_restJson1PropertyDefinitionsRequest = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: serializeAws_restJson1PropertyDefinitionRequest(value, context),
+        };
+    }, {});
+};
+const serializeAws_restJson1PropertyFilter = (input, context) => {
+    return {
+        ...(input.operator !== undefined && input.operator !== null && { operator: input.operator }),
+        ...(input.propertyName !== undefined && input.propertyName !== null && { propertyName: input.propertyName }),
+        ...(input.value !== undefined &&
+            input.value !== null && { value: serializeAws_restJson1DataValue(input.value, context) }),
+    };
+};
+const serializeAws_restJson1PropertyFilters = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1PropertyFilter(entry, context);
+    });
+};
+const serializeAws_restJson1PropertyRequest = (input, context) => {
+    return {
+        ...(input.definition !== undefined &&
+            input.definition !== null && {
+            definition: serializeAws_restJson1PropertyDefinitionRequest(input.definition, context),
+        }),
+        ...(input.updateType !== undefined && input.updateType !== null && { updateType: input.updateType }),
+        ...(input.value !== undefined &&
+            input.value !== null && { value: serializeAws_restJson1DataValue(input.value, context) }),
+    };
+};
+const serializeAws_restJson1PropertyRequests = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: serializeAws_restJson1PropertyRequest(value, context),
+        };
+    }, {});
+};
+const serializeAws_restJson1PropertyValue = (input, context) => {
+    return {
+        ...(input.timestamp !== undefined &&
+            input.timestamp !== null && { timestamp: Math.round(input.timestamp.getTime() / 1000) }),
+        ...(input.value !== undefined &&
+            input.value !== null && { value: serializeAws_restJson1DataValue(input.value, context) }),
+    };
+};
+const serializeAws_restJson1PropertyValueEntry = (input, context) => {
+    return {
+        ...(input.entityPropertyReference !== undefined &&
+            input.entityPropertyReference !== null && {
+            entityPropertyReference: serializeAws_restJson1EntityPropertyReference(input.entityPropertyReference, context),
+        }),
+        ...(input.propertyValues !== undefined &&
+            input.propertyValues !== null && {
+            propertyValues: serializeAws_restJson1PropertyValues(input.propertyValues, context),
+        }),
+    };
+};
+const serializeAws_restJson1PropertyValues = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1PropertyValue(entry, context);
+    });
+};
+const serializeAws_restJson1Relationship = (input, context) => {
+    return {
+        ...(input.relationshipType !== undefined &&
+            input.relationshipType !== null && { relationshipType: input.relationshipType }),
+        ...(input.targetComponentTypeId !== undefined &&
+            input.targetComponentTypeId !== null && { targetComponentTypeId: input.targetComponentTypeId }),
+    };
+};
+const serializeAws_restJson1RelationshipValue = (input, context) => {
+    return {
+        ...(input.targetComponentName !== undefined &&
+            input.targetComponentName !== null && { targetComponentName: input.targetComponentName }),
+        ...(input.targetEntityId !== undefined &&
+            input.targetEntityId !== null && { targetEntityId: input.targetEntityId }),
+    };
+};
+const serializeAws_restJson1RequiredProperties = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1SceneCapabilities = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1SelectedPropertyList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1TagMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const deserializeAws_restJson1BatchPutPropertyError = (output, context) => {
+    return {
+        entry: output.entry !== undefined && output.entry !== null
+            ? deserializeAws_restJson1PropertyValueEntry(output.entry, context)
+            : undefined,
+        errorCode: smithy_client_1.expectString(output.errorCode),
+        errorMessage: smithy_client_1.expectString(output.errorMessage),
+    };
+};
+const deserializeAws_restJson1BatchPutPropertyErrorEntry = (output, context) => {
+    return {
+        errors: output.errors !== undefined && output.errors !== null
+            ? deserializeAws_restJson1Errors(output.errors, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ComponentResponse = (output, context) => {
+    return {
+        componentName: smithy_client_1.expectString(output.componentName),
+        componentTypeId: smithy_client_1.expectString(output.componentTypeId),
+        definedIn: smithy_client_1.expectString(output.definedIn),
+        description: smithy_client_1.expectString(output.description),
+        properties: output.properties !== undefined && output.properties !== null
+            ? deserializeAws_restJson1PropertyResponses(output.properties, context)
+            : undefined,
+        status: output.status !== undefined && output.status !== null
+            ? deserializeAws_restJson1Status(output.status, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ComponentsMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: deserializeAws_restJson1ComponentResponse(value, context),
+        };
+    }, {});
+};
+const deserializeAws_restJson1ComponentTypeSummaries = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ComponentTypeSummary(entry, context);
+    });
+};
+const deserializeAws_restJson1ComponentTypeSummary = (output, context) => {
+    return {
+        arn: smithy_client_1.expectString(output.arn),
+        componentTypeId: smithy_client_1.expectString(output.componentTypeId),
+        creationDateTime: output.creationDateTime !== undefined && output.creationDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.creationDateTime)))
+            : undefined,
+        description: smithy_client_1.expectString(output.description),
+        status: output.status !== undefined && output.status !== null
+            ? deserializeAws_restJson1Status(output.status, context)
+            : undefined,
+        updateDateTime: output.updateDateTime !== undefined && output.updateDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.updateDateTime)))
+            : undefined,
+    };
+};
+const deserializeAws_restJson1Configuration = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: smithy_client_1.expectString(value),
+        };
+    }, {});
+};
+const deserializeAws_restJson1DataConnector = (output, context) => {
+    return {
+        isNative: smithy_client_1.expectBoolean(output.isNative),
+        lambda: output.lambda !== undefined && output.lambda !== null
+            ? deserializeAws_restJson1LambdaFunction(output.lambda, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1DataType = (output, context) => {
+    return {
+        allowedValues: output.allowedValues !== undefined && output.allowedValues !== null
+            ? deserializeAws_restJson1DataValueList(output.allowedValues, context)
+            : undefined,
+        nestedType: output.nestedType !== undefined && output.nestedType !== null
+            ? deserializeAws_restJson1DataType(output.nestedType, context)
+            : undefined,
+        relationship: output.relationship !== undefined && output.relationship !== null
+            ? deserializeAws_restJson1Relationship(output.relationship, context)
+            : undefined,
+        type: smithy_client_1.expectString(output.type),
+        unitOfMeasure: smithy_client_1.expectString(output.unitOfMeasure),
+    };
+};
+const deserializeAws_restJson1DataValue = (output, context) => {
+    return {
+        booleanValue: smithy_client_1.expectBoolean(output.booleanValue),
+        doubleValue: smithy_client_1.limitedParseDouble(output.doubleValue),
+        expression: smithy_client_1.expectString(output.expression),
+        integerValue: smithy_client_1.expectInt32(output.integerValue),
+        listValue: output.listValue !== undefined && output.listValue !== null
+            ? deserializeAws_restJson1DataValueList(output.listValue, context)
+            : undefined,
+        longValue: smithy_client_1.expectLong(output.longValue),
+        mapValue: output.mapValue !== undefined && output.mapValue !== null
+            ? deserializeAws_restJson1DataValueMap(output.mapValue, context)
+            : undefined,
+        relationshipValue: output.relationshipValue !== undefined && output.relationshipValue !== null
+            ? deserializeAws_restJson1RelationshipValue(output.relationshipValue, context)
+            : undefined,
+        stringValue: smithy_client_1.expectString(output.stringValue),
+    };
+};
+const deserializeAws_restJson1DataValueList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1DataValue(entry, context);
+    });
+};
+const deserializeAws_restJson1DataValueMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: deserializeAws_restJson1DataValue(value, context),
+        };
+    }, {});
+};
+const deserializeAws_restJson1EntityPropertyReference = (output, context) => {
+    return {
+        componentName: smithy_client_1.expectString(output.componentName),
+        entityId: smithy_client_1.expectString(output.entityId),
+        externalIdProperty: output.externalIdProperty !== undefined && output.externalIdProperty !== null
+            ? deserializeAws_restJson1ExternalIdProperty(output.externalIdProperty, context)
+            : undefined,
+        propertyName: smithy_client_1.expectString(output.propertyName),
+    };
+};
+const deserializeAws_restJson1EntitySummaries = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EntitySummary(entry, context);
+    });
+};
+const deserializeAws_restJson1EntitySummary = (output, context) => {
+    return {
+        arn: smithy_client_1.expectString(output.arn),
+        creationDateTime: output.creationDateTime !== undefined && output.creationDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.creationDateTime)))
+            : undefined,
+        description: smithy_client_1.expectString(output.description),
+        entityId: smithy_client_1.expectString(output.entityId),
+        entityName: smithy_client_1.expectString(output.entityName),
+        hasChildEntities: smithy_client_1.expectBoolean(output.hasChildEntities),
+        parentEntityId: smithy_client_1.expectString(output.parentEntityId),
+        status: output.status !== undefined && output.status !== null
+            ? deserializeAws_restJson1Status(output.status, context)
+            : undefined,
+        updateDateTime: output.updateDateTime !== undefined && output.updateDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.updateDateTime)))
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ErrorDetails = (output, context) => {
+    return {
+        code: smithy_client_1.expectString(output.code),
+        message: smithy_client_1.expectString(output.message),
+    };
+};
+const deserializeAws_restJson1ErrorEntries = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1BatchPutPropertyErrorEntry(entry, context);
+    });
+};
+const deserializeAws_restJson1Errors = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1BatchPutPropertyError(entry, context);
+    });
+};
+const deserializeAws_restJson1ExtendsFrom = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_restJson1ExternalIdProperty = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: smithy_client_1.expectString(value),
+        };
+    }, {});
+};
+const deserializeAws_restJson1FunctionResponse = (output, context) => {
+    return {
+        implementedBy: output.implementedBy !== undefined && output.implementedBy !== null
+            ? deserializeAws_restJson1DataConnector(output.implementedBy, context)
+            : undefined,
+        isInherited: smithy_client_1.expectBoolean(output.isInherited),
+        requiredProperties: output.requiredProperties !== undefined && output.requiredProperties !== null
+            ? deserializeAws_restJson1RequiredProperties(output.requiredProperties, context)
+            : undefined,
+        scope: smithy_client_1.expectString(output.scope),
+    };
+};
+const deserializeAws_restJson1FunctionsResponse = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: deserializeAws_restJson1FunctionResponse(value, context),
+        };
+    }, {});
+};
+const deserializeAws_restJson1LambdaFunction = (output, context) => {
+    return {
+        arn: smithy_client_1.expectString(output.arn),
+    };
+};
+const deserializeAws_restJson1PropertyDefinitionResponse = (output, context) => {
+    return {
+        configuration: output.configuration !== undefined && output.configuration !== null
+            ? deserializeAws_restJson1Configuration(output.configuration, context)
+            : undefined,
+        dataType: output.dataType !== undefined && output.dataType !== null
+            ? deserializeAws_restJson1DataType(output.dataType, context)
+            : undefined,
+        defaultValue: output.defaultValue !== undefined && output.defaultValue !== null
+            ? deserializeAws_restJson1DataValue(output.defaultValue, context)
+            : undefined,
+        isExternalId: smithy_client_1.expectBoolean(output.isExternalId),
+        isFinal: smithy_client_1.expectBoolean(output.isFinal),
+        isImported: smithy_client_1.expectBoolean(output.isImported),
+        isInherited: smithy_client_1.expectBoolean(output.isInherited),
+        isRequiredInEntity: smithy_client_1.expectBoolean(output.isRequiredInEntity),
+        isStoredExternally: smithy_client_1.expectBoolean(output.isStoredExternally),
+        isTimeSeries: smithy_client_1.expectBoolean(output.isTimeSeries),
+    };
+};
+const deserializeAws_restJson1PropertyDefinitionsResponse = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: deserializeAws_restJson1PropertyDefinitionResponse(value, context),
+        };
+    }, {});
+};
+const deserializeAws_restJson1PropertyLatestValue = (output, context) => {
+    return {
+        propertyReference: output.propertyReference !== undefined && output.propertyReference !== null
+            ? deserializeAws_restJson1EntityPropertyReference(output.propertyReference, context)
+            : undefined,
+        propertyValue: output.propertyValue !== undefined && output.propertyValue !== null
+            ? deserializeAws_restJson1DataValue(output.propertyValue, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1PropertyLatestValueMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: deserializeAws_restJson1PropertyLatestValue(value, context),
+        };
+    }, {});
+};
+const deserializeAws_restJson1PropertyResponse = (output, context) => {
+    return {
+        definition: output.definition !== undefined && output.definition !== null
+            ? deserializeAws_restJson1PropertyDefinitionResponse(output.definition, context)
+            : undefined,
+        value: output.value !== undefined && output.value !== null
+            ? deserializeAws_restJson1DataValue(output.value, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1PropertyResponses = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: deserializeAws_restJson1PropertyResponse(value, context),
+        };
+    }, {});
+};
+const deserializeAws_restJson1PropertyValue = (output, context) => {
+    return {
+        timestamp: output.timestamp !== undefined && output.timestamp !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.timestamp)))
+            : undefined,
+        value: output.value !== undefined && output.value !== null
+            ? deserializeAws_restJson1DataValue(output.value, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1PropertyValueEntry = (output, context) => {
+    return {
+        entityPropertyReference: output.entityPropertyReference !== undefined && output.entityPropertyReference !== null
+            ? deserializeAws_restJson1EntityPropertyReference(output.entityPropertyReference, context)
+            : undefined,
+        propertyValues: output.propertyValues !== undefined && output.propertyValues !== null
+            ? deserializeAws_restJson1PropertyValues(output.propertyValues, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1PropertyValueHistory = (output, context) => {
+    return {
+        entityPropertyReference: output.entityPropertyReference !== undefined && output.entityPropertyReference !== null
+            ? deserializeAws_restJson1EntityPropertyReference(output.entityPropertyReference, context)
+            : undefined,
+        values: output.values !== undefined && output.values !== null
+            ? deserializeAws_restJson1Values(output.values, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1PropertyValueList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1PropertyValueHistory(entry, context);
+    });
+};
+const deserializeAws_restJson1PropertyValues = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1PropertyValue(entry, context);
+    });
+};
+const deserializeAws_restJson1Relationship = (output, context) => {
+    return {
+        relationshipType: smithy_client_1.expectString(output.relationshipType),
+        targetComponentTypeId: smithy_client_1.expectString(output.targetComponentTypeId),
+    };
+};
+const deserializeAws_restJson1RelationshipValue = (output, context) => {
+    return {
+        targetComponentName: smithy_client_1.expectString(output.targetComponentName),
+        targetEntityId: smithy_client_1.expectString(output.targetEntityId),
+    };
+};
+const deserializeAws_restJson1RequiredProperties = (output, context) => {
+    const uniqueValues = new Set();
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        const parsedEntry = smithy_client_1.expectString(entry);
+        if (uniqueValues.has(parsedEntry)) {
+            throw new TypeError('All elements of the set "com.amazonaws.iottwinmaker#RequiredProperties" must be unique.');
+        }
+        else {
+            uniqueValues.add(parsedEntry);
+            return parsedEntry;
+        }
+    });
+};
+const deserializeAws_restJson1SceneCapabilities = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_restJson1SceneSummaries = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1SceneSummary(entry, context);
+    });
+};
+const deserializeAws_restJson1SceneSummary = (output, context) => {
+    return {
+        arn: smithy_client_1.expectString(output.arn),
+        contentLocation: smithy_client_1.expectString(output.contentLocation),
+        creationDateTime: output.creationDateTime !== undefined && output.creationDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.creationDateTime)))
+            : undefined,
+        description: smithy_client_1.expectString(output.description),
+        sceneId: smithy_client_1.expectString(output.sceneId),
+        updateDateTime: output.updateDateTime !== undefined && output.updateDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.updateDateTime)))
+            : undefined,
+    };
+};
+const deserializeAws_restJson1Status = (output, context) => {
+    return {
+        error: output.error !== undefined && output.error !== null
+            ? deserializeAws_restJson1ErrorDetails(output.error, context)
+            : undefined,
+        state: smithy_client_1.expectString(output.state),
+    };
+};
+const deserializeAws_restJson1TagMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: smithy_client_1.expectString(value),
+        };
+    }, {});
+};
+const deserializeAws_restJson1Values = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1PropertyValue(entry, context);
+    });
+};
+const deserializeAws_restJson1WorkspaceSummaries = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1WorkspaceSummary(entry, context);
+    });
+};
+const deserializeAws_restJson1WorkspaceSummary = (output, context) => {
+    return {
+        arn: smithy_client_1.expectString(output.arn),
+        creationDateTime: output.creationDateTime !== undefined && output.creationDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.creationDateTime)))
+            : undefined,
+        description: smithy_client_1.expectString(output.description),
+        updateDateTime: output.updateDateTime !== undefined && output.updateDateTime !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.updateDateTime)))
+            : undefined,
+        workspaceId: smithy_client_1.expectString(output.workspaceId),
+    };
+};
+const deserializeMetadata = (output) => {
+    var _a;
+    return ({
+        httpStatusCode: output.statusCode,
+        requestId: (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"],
+        extendedRequestId: output.headers["x-amz-id-2"],
+        cfId: output.headers["x-amz-cf-id"],
+    });
+};
+const collectBody = (streamBody = new Uint8Array(), context) => {
+    if (streamBody instanceof Uint8Array) {
+        return Promise.resolve(streamBody);
+    }
+    return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
+};
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+const isSerializableHeaderValue = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
+    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    if (encoded.length) {
+        return JSON.parse(encoded);
+    }
+    return {};
+});
+const loadRestJsonErrorCode = (output, data) => {
+    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    if (headerKey !== undefined) {
+        return sanitizeErrorCode(output.headers[headerKey]);
+    }
+    if (data.code !== undefined) {
+        return sanitizeErrorCode(data.code);
+    }
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
+    }
+    return "";
+};