@aws-sdk/client-rum 3.44.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -0,0 +1,1502 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeAws_restJson1UpdateAppMonitorCommand = exports.deserializeAws_restJson1UntagResourceCommand = exports.deserializeAws_restJson1TagResourceCommand = exports.deserializeAws_restJson1PutRumEventsCommand = exports.deserializeAws_restJson1ListTagsForResourceCommand = exports.deserializeAws_restJson1ListAppMonitorsCommand = exports.deserializeAws_restJson1GetAppMonitorDataCommand = exports.deserializeAws_restJson1GetAppMonitorCommand = exports.deserializeAws_restJson1DeleteAppMonitorCommand = exports.deserializeAws_restJson1CreateAppMonitorCommand = exports.serializeAws_restJson1UpdateAppMonitorCommand = exports.serializeAws_restJson1UntagResourceCommand = exports.serializeAws_restJson1TagResourceCommand = exports.serializeAws_restJson1PutRumEventsCommand = exports.serializeAws_restJson1ListTagsForResourceCommand = exports.serializeAws_restJson1ListAppMonitorsCommand = exports.serializeAws_restJson1GetAppMonitorDataCommand = exports.serializeAws_restJson1GetAppMonitorCommand = exports.serializeAws_restJson1DeleteAppMonitorCommand = exports.serializeAws_restJson1CreateAppMonitorCommand = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const serializeAws_restJson1CreateAppMonitorCommand = 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 || ""}` + "/appmonitor";
+    let body;
+    body = JSON.stringify({
+        ...(input.AppMonitorConfiguration !== undefined &&
+            input.AppMonitorConfiguration !== null && {
+            AppMonitorConfiguration: serializeAws_restJson1AppMonitorConfiguration(input.AppMonitorConfiguration, context),
+        }),
+        ...(input.CwLogEnabled !== undefined && input.CwLogEnabled !== null && { CwLogEnabled: input.CwLogEnabled }),
+        ...(input.Domain !== undefined && input.Domain !== null && { Domain: input.Domain }),
+        ...(input.Name !== undefined && input.Name !== null && { Name: input.Name }),
+        ...(input.Tags !== undefined && input.Tags !== null && { Tags: serializeAws_restJson1TagMap(input.Tags, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateAppMonitorCommand = serializeAws_restJson1CreateAppMonitorCommand;
+const serializeAws_restJson1DeleteAppMonitorCommand = 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 || ""}` + "/appmonitor/{Name}";
+    if (input.Name !== undefined) {
+        const labelValue = input.Name;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: Name.");
+        }
+        resolvedPath = resolvedPath.replace("{Name}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: Name.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteAppMonitorCommand = serializeAws_restJson1DeleteAppMonitorCommand;
+const serializeAws_restJson1GetAppMonitorCommand = 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 || ""}` + "/appmonitor/{Name}";
+    if (input.Name !== undefined) {
+        const labelValue = input.Name;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: Name.");
+        }
+        resolvedPath = resolvedPath.replace("{Name}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: Name.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetAppMonitorCommand = serializeAws_restJson1GetAppMonitorCommand;
+const serializeAws_restJson1GetAppMonitorDataCommand = 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 || ""}` + "/appmonitor/{Name}/data";
+    if (input.Name !== undefined) {
+        const labelValue = input.Name;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: Name.");
+        }
+        resolvedPath = resolvedPath.replace("{Name}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: Name.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.Filters !== undefined &&
+            input.Filters !== null && { Filters: serializeAws_restJson1QueryFilters(input.Filters, context) }),
+        ...(input.MaxResults !== undefined && input.MaxResults !== null && { MaxResults: input.MaxResults }),
+        ...(input.NextToken !== undefined && input.NextToken !== null && { NextToken: input.NextToken }),
+        ...(input.TimeRange !== undefined &&
+            input.TimeRange !== null && { TimeRange: serializeAws_restJson1TimeRange(input.TimeRange, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetAppMonitorDataCommand = serializeAws_restJson1GetAppMonitorDataCommand;
+const serializeAws_restJson1ListAppMonitorsCommand = 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 || ""}` + "/appmonitors";
+    const query = {
+        ...(input.MaxResults !== undefined && { maxResults: input.MaxResults.toString() }),
+        ...(input.NextToken !== undefined && { nextToken: input.NextToken }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListAppMonitorsCommand = serializeAws_restJson1ListAppMonitorsCommand;
+const serializeAws_restJson1ListTagsForResourceCommand = 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 || ""}` + "/tags/{ResourceArn}";
+    if (input.ResourceArn !== undefined) {
+        const labelValue = input.ResourceArn;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: ResourceArn.");
+        }
+        resolvedPath = resolvedPath.replace("{ResourceArn}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: ResourceArn.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListTagsForResourceCommand = serializeAws_restJson1ListTagsForResourceCommand;
+const serializeAws_restJson1PutRumEventsCommand = 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 || ""}` + "/appmonitors/{Id}";
+    if (input.Id !== undefined) {
+        const labelValue = input.Id;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: Id.");
+        }
+        resolvedPath = resolvedPath.replace("{Id}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: Id.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.AppMonitorDetails !== undefined &&
+            input.AppMonitorDetails !== null && {
+            AppMonitorDetails: serializeAws_restJson1AppMonitorDetails(input.AppMonitorDetails, context),
+        }),
+        ...(input.BatchId !== undefined && input.BatchId !== null && { BatchId: input.BatchId }),
+        ...(input.RumEvents !== undefined &&
+            input.RumEvents !== null && { RumEvents: serializeAws_restJson1RumEventList(input.RumEvents, context) }),
+        ...(input.UserDetails !== undefined &&
+            input.UserDetails !== null && { UserDetails: serializeAws_restJson1UserDetails(input.UserDetails, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "dataplane." + 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_restJson1PutRumEventsCommand = serializeAws_restJson1PutRumEventsCommand;
+const serializeAws_restJson1TagResourceCommand = 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 || ""}` + "/tags/{ResourceArn}";
+    if (input.ResourceArn !== undefined) {
+        const labelValue = input.ResourceArn;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: ResourceArn.");
+        }
+        resolvedPath = resolvedPath.replace("{ResourceArn}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: ResourceArn.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.Tags !== undefined && input.Tags !== null && { Tags: serializeAws_restJson1TagMap(input.Tags, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        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 = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
+    if (input.ResourceArn !== undefined) {
+        const labelValue = input.ResourceArn;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: ResourceArn.");
+        }
+        resolvedPath = resolvedPath.replace("{ResourceArn}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: ResourceArn.");
+    }
+    const query = {
+        ...(input.TagKeys !== undefined && { tagKeys: (input.TagKeys || []).map((_entry) => _entry) }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1UntagResourceCommand = serializeAws_restJson1UntagResourceCommand;
+const serializeAws_restJson1UpdateAppMonitorCommand = 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 || ""}` + "/appmonitor/{Name}";
+    if (input.Name !== undefined) {
+        const labelValue = input.Name;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: Name.");
+        }
+        resolvedPath = resolvedPath.replace("{Name}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: Name.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.AppMonitorConfiguration !== undefined &&
+            input.AppMonitorConfiguration !== null && {
+            AppMonitorConfiguration: serializeAws_restJson1AppMonitorConfiguration(input.AppMonitorConfiguration, context),
+        }),
+        ...(input.CwLogEnabled !== undefined && input.CwLogEnabled !== null && { CwLogEnabled: input.CwLogEnabled }),
+        ...(input.Domain !== undefined && input.Domain !== null && { Domain: input.Domain }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateAppMonitorCommand = serializeAws_restJson1UpdateAppMonitorCommand;
+const deserializeAws_restJson1CreateAppMonitorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateAppMonitorCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Id: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Id !== undefined && data.Id !== null) {
+        contents.Id = smithy_client_1.expectString(data.Id);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateAppMonitorCommand = deserializeAws_restJson1CreateAppMonitorCommand;
+const deserializeAws_restJson1CreateAppMonitorCommandError = 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.rum#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.rum#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.rum#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.rum#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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_restJson1DeleteAppMonitorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteAppMonitorCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1DeleteAppMonitorCommand = deserializeAws_restJson1DeleteAppMonitorCommand;
+const deserializeAws_restJson1DeleteAppMonitorCommandError = 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.rum#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.rum#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.rum#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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_restJson1GetAppMonitorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetAppMonitorCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        AppMonitor: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.AppMonitor !== undefined && data.AppMonitor !== null) {
+        contents.AppMonitor = deserializeAws_restJson1AppMonitor(data.AppMonitor, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetAppMonitorCommand = deserializeAws_restJson1GetAppMonitorCommand;
+const deserializeAws_restJson1GetAppMonitorCommandError = 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.rum#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.rum#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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_restJson1GetAppMonitorDataCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetAppMonitorDataCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Events: undefined,
+        NextToken: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Events !== undefined && data.Events !== null) {
+        contents.Events = deserializeAws_restJson1EventDataList(data.Events, context);
+    }
+    if (data.NextToken !== undefined && data.NextToken !== null) {
+        contents.NextToken = smithy_client_1.expectString(data.NextToken);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetAppMonitorDataCommand = deserializeAws_restJson1GetAppMonitorDataCommand;
+const deserializeAws_restJson1GetAppMonitorDataCommandError = 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.rum#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.rum#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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_restJson1ListAppMonitorsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListAppMonitorsCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        AppMonitorSummaries: undefined,
+        NextToken: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.AppMonitorSummaries !== undefined && data.AppMonitorSummaries !== null) {
+        contents.AppMonitorSummaries = deserializeAws_restJson1AppMonitorSummaryList(data.AppMonitorSummaries, context);
+    }
+    if (data.NextToken !== undefined && data.NextToken !== null) {
+        contents.NextToken = smithy_client_1.expectString(data.NextToken);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListAppMonitorsCommand = deserializeAws_restJson1ListAppMonitorsCommand;
+const deserializeAws_restJson1ListAppMonitorsCommandError = 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.rum#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.rum#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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),
+        ResourceArn: undefined,
+        Tags: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.ResourceArn !== undefined && data.ResourceArn !== null) {
+        contents.ResourceArn = smithy_client_1.expectString(data.ResourceArn);
+    }
+    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 "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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_restJson1PutRumEventsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1PutRumEventsCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1PutRumEventsCommand = deserializeAws_restJson1PutRumEventsCommand;
+const deserializeAws_restJson1PutRumEventsCommandError = 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.rum#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.rum#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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 "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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_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 "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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_restJson1UpdateAppMonitorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateAppMonitorCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1UpdateAppMonitorCommand = deserializeAws_restJson1UpdateAppMonitorCommand;
+const deserializeAws_restJson1UpdateAppMonitorCommandError = 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.rum#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.rum#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.rum#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rum#ResourceNotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ThrottlingException":
+        case "com.amazonaws.rum#ThrottlingException":
+            response = {
+                ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.rum#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,
+        resourceName: undefined,
+        resourceType: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    if (data.resourceName !== undefined && data.resourceName !== null) {
+        contents.resourceName = smithy_client_1.expectString(data.resourceName);
+    }
+    if (data.resourceType !== undefined && data.resourceType !== null) {
+        contents.resourceType = smithy_client_1.expectString(data.resourceType);
+    }
+    return contents;
+};
+const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const contents = {
+        name: "InternalServerException",
+        $fault: "server",
+        $retryable: {},
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+        retryAfterSeconds: undefined,
+    };
+    if (parsedOutput.headers["retry-after"] !== undefined) {
+        contents.retryAfterSeconds = smithy_client_1.strictParseInt32(parsedOutput.headers["retry-after"]);
+    }
+    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,
+        resourceName: undefined,
+        resourceType: undefined,
+    };
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    if (data.resourceName !== undefined && data.resourceName !== null) {
+        contents.resourceName = smithy_client_1.expectString(data.resourceName);
+    }
+    if (data.resourceType !== undefined && data.resourceType !== null) {
+        contents.resourceType = smithy_client_1.expectString(data.resourceType);
+    }
+    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",
+        $retryable: {
+            throttling: true,
+        },
+        $metadata: deserializeMetadata(parsedOutput),
+        message: undefined,
+        quotaCode: undefined,
+        retryAfterSeconds: undefined,
+        serviceCode: undefined,
+    };
+    if (parsedOutput.headers["retry-after"] !== undefined) {
+        contents.retryAfterSeconds = smithy_client_1.strictParseInt32(parsedOutput.headers["retry-after"]);
+    }
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = smithy_client_1.expectString(data.message);
+    }
+    if (data.quotaCode !== undefined && data.quotaCode !== null) {
+        contents.quotaCode = smithy_client_1.expectString(data.quotaCode);
+    }
+    if (data.serviceCode !== undefined && data.serviceCode !== null) {
+        contents.serviceCode = smithy_client_1.expectString(data.serviceCode);
+    }
+    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_restJson1AppMonitorConfiguration = (input, context) => {
+    return {
+        ...(input.AllowCookies !== undefined && input.AllowCookies !== null && { AllowCookies: input.AllowCookies }),
+        ...(input.EnableXRay !== undefined && input.EnableXRay !== null && { EnableXRay: input.EnableXRay }),
+        ...(input.ExcludedPages !== undefined &&
+            input.ExcludedPages !== null && { ExcludedPages: serializeAws_restJson1Pages(input.ExcludedPages, context) }),
+        ...(input.FavoritePages !== undefined &&
+            input.FavoritePages !== null && {
+            FavoritePages: serializeAws_restJson1FavoritePages(input.FavoritePages, context),
+        }),
+        ...(input.GuestRoleArn !== undefined && input.GuestRoleArn !== null && { GuestRoleArn: input.GuestRoleArn }),
+        ...(input.IdentityPoolId !== undefined &&
+            input.IdentityPoolId !== null && { IdentityPoolId: input.IdentityPoolId }),
+        ...(input.IncludedPages !== undefined &&
+            input.IncludedPages !== null && { IncludedPages: serializeAws_restJson1Pages(input.IncludedPages, context) }),
+        ...(input.SessionSampleRate !== undefined &&
+            input.SessionSampleRate !== null && { SessionSampleRate: smithy_client_1.serializeFloat(input.SessionSampleRate) }),
+        ...(input.Telemetries !== undefined &&
+            input.Telemetries !== null && { Telemetries: serializeAws_restJson1Telemetries(input.Telemetries, context) }),
+    };
+};
+const serializeAws_restJson1AppMonitorDetails = (input, context) => {
+    return {
+        ...(input.id !== undefined && input.id !== null && { id: input.id }),
+        ...(input.name !== undefined && input.name !== null && { name: input.name }),
+        ...(input.version !== undefined && input.version !== null && { version: input.version }),
+    };
+};
+const serializeAws_restJson1FavoritePages = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1Pages = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1QueryFilter = (input, context) => {
+    return {
+        ...(input.Name !== undefined && input.Name !== null && { Name: input.Name }),
+        ...(input.Values !== undefined &&
+            input.Values !== null && { Values: serializeAws_restJson1QueryFilterValueList(input.Values, context) }),
+    };
+};
+const serializeAws_restJson1QueryFilters = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1QueryFilter(entry, context);
+    });
+};
+const serializeAws_restJson1QueryFilterValueList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1RumEvent = (input, context) => {
+    return {
+        ...(input.details !== undefined &&
+            input.details !== null && { details: smithy_client_1.LazyJsonString.fromObject(input.details) }),
+        ...(input.id !== undefined && input.id !== null && { id: input.id }),
+        ...(input.metadata !== undefined &&
+            input.metadata !== null && { metadata: smithy_client_1.LazyJsonString.fromObject(input.metadata) }),
+        ...(input.timestamp !== undefined &&
+            input.timestamp !== null && { timestamp: Math.round(input.timestamp.getTime() / 1000) }),
+        ...(input.type !== undefined && input.type !== null && { type: input.type }),
+    };
+};
+const serializeAws_restJson1RumEventList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1RumEvent(entry, context);
+    });
+};
+const serializeAws_restJson1TagMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const serializeAws_restJson1Telemetries = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return entry;
+    });
+};
+const serializeAws_restJson1TimeRange = (input, context) => {
+    return {
+        ...(input.After !== undefined && input.After !== null && { After: input.After }),
+        ...(input.Before !== undefined && input.Before !== null && { Before: input.Before }),
+    };
+};
+const serializeAws_restJson1UserDetails = (input, context) => {
+    return {
+        ...(input.sessionId !== undefined && input.sessionId !== null && { sessionId: input.sessionId }),
+        ...(input.userId !== undefined && input.userId !== null && { userId: input.userId }),
+    };
+};
+const deserializeAws_restJson1AppMonitor = (output, context) => {
+    return {
+        AppMonitorConfiguration: output.AppMonitorConfiguration !== undefined && output.AppMonitorConfiguration !== null
+            ? deserializeAws_restJson1AppMonitorConfiguration(output.AppMonitorConfiguration, context)
+            : undefined,
+        Created: smithy_client_1.expectString(output.Created),
+        DataStorage: output.DataStorage !== undefined && output.DataStorage !== null
+            ? deserializeAws_restJson1DataStorage(output.DataStorage, context)
+            : undefined,
+        Domain: smithy_client_1.expectString(output.Domain),
+        Id: smithy_client_1.expectString(output.Id),
+        LastModified: smithy_client_1.expectString(output.LastModified),
+        Name: smithy_client_1.expectString(output.Name),
+        State: smithy_client_1.expectString(output.State),
+        Tags: output.Tags !== undefined && output.Tags !== null
+            ? deserializeAws_restJson1TagMap(output.Tags, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1AppMonitorConfiguration = (output, context) => {
+    return {
+        AllowCookies: smithy_client_1.expectBoolean(output.AllowCookies),
+        EnableXRay: smithy_client_1.expectBoolean(output.EnableXRay),
+        ExcludedPages: output.ExcludedPages !== undefined && output.ExcludedPages !== null
+            ? deserializeAws_restJson1Pages(output.ExcludedPages, context)
+            : undefined,
+        FavoritePages: output.FavoritePages !== undefined && output.FavoritePages !== null
+            ? deserializeAws_restJson1FavoritePages(output.FavoritePages, context)
+            : undefined,
+        GuestRoleArn: smithy_client_1.expectString(output.GuestRoleArn),
+        IdentityPoolId: smithy_client_1.expectString(output.IdentityPoolId),
+        IncludedPages: output.IncludedPages !== undefined && output.IncludedPages !== null
+            ? deserializeAws_restJson1Pages(output.IncludedPages, context)
+            : undefined,
+        SessionSampleRate: smithy_client_1.limitedParseDouble(output.SessionSampleRate),
+        Telemetries: output.Telemetries !== undefined && output.Telemetries !== null
+            ? deserializeAws_restJson1Telemetries(output.Telemetries, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1AppMonitorSummary = (output, context) => {
+    return {
+        Created: smithy_client_1.expectString(output.Created),
+        Id: smithy_client_1.expectString(output.Id),
+        LastModified: smithy_client_1.expectString(output.LastModified),
+        Name: smithy_client_1.expectString(output.Name),
+        State: smithy_client_1.expectString(output.State),
+    };
+};
+const deserializeAws_restJson1AppMonitorSummaryList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1AppMonitorSummary(entry, context);
+    });
+};
+const deserializeAws_restJson1CwLog = (output, context) => {
+    return {
+        CwLogEnabled: smithy_client_1.expectBoolean(output.CwLogEnabled),
+        CwLogGroup: smithy_client_1.expectString(output.CwLogGroup),
+    };
+};
+const deserializeAws_restJson1DataStorage = (output, context) => {
+    return {
+        CwLog: output.CwLog !== undefined && output.CwLog !== null
+            ? deserializeAws_restJson1CwLog(output.CwLog, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1EventDataList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_restJson1FavoritePages = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_restJson1Pages = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+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_restJson1Telemetries = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+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 "";
+};