@aws-sdk/client-neptunedata 3.403.0

package/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,4681 @@
+import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
+import { AccessDeniedException, BadRequestException, BulkLoadIdNotFoundException, CancelledByUserException, ClientTimeoutException, ConcurrentModificationException, ConstraintViolationException, ExpiredStreamException, FailureByQueryException, IllegalArgumentException, InternalFailureException, InvalidArgumentException, InvalidNumericDataException, InvalidParameterException, LoadUrlAccessDeniedException, MalformedQueryException, MemoryLimitExceededException, MethodNotAllowedException, MissingParameterException, MLResourceNotFoundException, ParsingException, PreconditionsFailedException, QueryLimitExceededException, QueryLimitException, QueryTooLargeException, ReadOnlyViolationException, S3Exception, ServerShutdownException, StatisticsNotAvailableException, StreamRecordsNotFoundException, ThrottlingException, TimeLimitExceededException, TooManyRequestsException, UnsupportedOperationException, } from "../models/models_0";
+import { NeptunedataServiceException as __BaseException } from "../models/NeptunedataServiceException";
+export const se_CancelGremlinQueryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/status/{queryId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_CancelLoaderJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader/{loadId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "loadId", () => input.loadId, "{loadId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_CancelMLDataProcessingJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+        clean: [() => input.clean !== void 0, () => input.clean.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_CancelMLModelTrainingJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+        clean: [() => input.clean !== void 0, () => input.clean.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_CancelMLModelTransformJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+        clean: [() => input.clean !== void 0, () => input.clean.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_CancelOpenCypherQueryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/status/{queryId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
+    const query = map({
+        silent: [() => input.silent !== void 0, () => input.silent.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_CreateMLEndpointCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints";
+    let body;
+    body = JSON.stringify(take(input, {
+        id: [],
+        instanceCount: [],
+        instanceType: [],
+        mlModelTrainingJobId: [],
+        mlModelTransformJobId: [],
+        modelName: [],
+        neptuneIamRoleArn: [],
+        update: [],
+        volumeEncryptionKMSKey: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DeleteMLEndpointCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+        clean: [() => input.clean !== void 0, () => input.clean.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_DeletePropertygraphStatisticsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics";
+    let body;
+    body = "";
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DeleteSparqlStatisticsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/statistics";
+    let body;
+    body = "";
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ExecuteFastResetCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/system";
+    let body;
+    body = JSON.stringify(take(input, {
+        action: [],
+        token: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ExecuteGremlinExplainQueryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/explain";
+    let body;
+    body = JSON.stringify(take(input, {
+        gremlin: [, , `gremlinQuery`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ExecuteGremlinProfileQueryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/profile";
+    let body;
+    body = JSON.stringify(take(input, {
+        "profile.chop": [, , `chop`],
+        gremlin: [, , `gremlinQuery`],
+        "profile.indexOps": [, , `indexOps`],
+        "profile.results": [, , `results`],
+        "profile.serializer": [, , `serializer`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ExecuteGremlinQueryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        accept: input.serializer,
+    });
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin";
+    let body;
+    body = JSON.stringify(take(input, {
+        gremlin: [, , `gremlinQuery`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ExecuteOpenCypherExplainQueryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/explain";
+    let body;
+    body = JSON.stringify(take(input, {
+        explain: [, , `explainMode`],
+        query: [, , `openCypherQuery`],
+        parameters: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ExecuteOpenCypherQueryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher";
+    let body;
+    body = JSON.stringify(take(input, {
+        query: [, , `openCypherQuery`],
+        parameters: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetEngineStatusCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/status";
+    let body;
+    body = "";
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetGremlinQueryStatusCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/status/{queryId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetLoaderJobStatusCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader/{loadId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "loadId", () => input.loadId, "{loadId}", false);
+    const query = map({
+        details: [() => input.details !== void 0, () => input.details.toString()],
+        errors: [() => input.errors !== void 0, () => input.errors.toString()],
+        page: [() => input.page !== void 0, () => input.page.toString()],
+        errorsPerPage: [() => input.errorsPerPage !== void 0, () => input.errorsPerPage.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetMLDataProcessingJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetMLEndpointCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetMLModelTrainingJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetMLModelTransformJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    const query = map({
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetOpenCypherQueryStatusCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/status/{queryId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "queryId", () => input.queryId, "{queryId}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetPropertygraphStatisticsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics";
+    let body;
+    body = "";
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetPropertygraphStreamCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "accept-encoding": input.encoding,
+    });
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/stream";
+    const query = map({
+        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        iteratorType: [, input.iteratorType],
+        commitNum: [() => input.commitNum !== void 0, () => input.commitNum.toString()],
+        opNum: [() => input.opNum !== void 0, () => input.opNum.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetPropertygraphSummaryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics/summary";
+    const query = map({
+        mode: [, input.mode],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetRDFGraphSummaryCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rdf/statistics/summary";
+    const query = map({
+        mode: [, input.mode],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetSparqlStatisticsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/statistics";
+    let body;
+    body = "";
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_GetSparqlStreamCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "accept-encoding": input.encoding,
+    });
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/stream";
+    const query = map({
+        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        iteratorType: [, input.iteratorType],
+        commitNum: [() => input.commitNum !== void 0, () => input.commitNum.toString()],
+        opNum: [() => input.opNum !== void 0, () => input.opNum.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListGremlinQueriesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/gremlin/status";
+    const query = map({
+        includeWaiting: [() => input.includeWaiting !== void 0, () => input.includeWaiting.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListLoaderJobsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader";
+    const query = map({
+        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        includeQueuedLoads: [() => input.includeQueuedLoads !== void 0, () => input.includeQueuedLoads.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListMLDataProcessingJobsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing";
+    const query = map({
+        maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListMLEndpointsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/endpoints";
+    const query = map({
+        maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListMLModelTrainingJobsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining";
+    const query = map({
+        maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListMLModelTransformJobsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform";
+    const query = map({
+        maxItems: [() => input.maxItems !== void 0, () => input.maxItems.toString()],
+        neptuneIamRoleArn: [, input.neptuneIamRoleArn],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ListOpenCypherQueriesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/opencypher/status";
+    const query = map({
+        includeWaiting: [() => input.includeWaiting !== void 0, () => input.includeWaiting.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_ManagePropertygraphStatisticsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/propertygraph/statistics";
+    let body;
+    body = JSON.stringify(take(input, {
+        mode: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ManageSparqlStatisticsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sparql/statistics";
+    let body;
+    body = JSON.stringify(take(input, {
+        mode: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_StartLoaderJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/loader";
+    let body;
+    body = JSON.stringify(take(input, {
+        dependencies: (_) => _json(_),
+        failOnError: [],
+        format: [],
+        iamRoleArn: [],
+        mode: [],
+        parallelism: [],
+        parserConfiguration: (_) => _json(_),
+        queueRequest: [],
+        region: [, , `s3BucketRegion`],
+        source: [],
+        updateSingleCardinalityProperties: [],
+        userProvidedEdgeIds: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_StartMLDataProcessingJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/dataprocessing";
+    let body;
+    body = JSON.stringify(take(input, {
+        configFileName: [],
+        id: [],
+        inputDataS3Location: [],
+        modelType: [],
+        neptuneIamRoleArn: [],
+        previousDataProcessingJobId: [],
+        processedDataS3Location: [],
+        processingInstanceType: [],
+        processingInstanceVolumeSizeInGB: [],
+        processingTimeOutInSeconds: [],
+        s3OutputEncryptionKMSKey: [],
+        sagemakerIamRoleArn: [],
+        securityGroupIds: (_) => _json(_),
+        subnets: (_) => _json(_),
+        volumeEncryptionKMSKey: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_StartMLModelTrainingJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltraining";
+    let body;
+    body = JSON.stringify(take(input, {
+        baseProcessingInstanceType: [],
+        customModelTrainingParameters: (_) => _json(_),
+        dataProcessingJobId: [],
+        enableManagedSpotTraining: [],
+        id: [],
+        maxHPONumberOfTrainingJobs: [],
+        maxHPOParallelTrainingJobs: [],
+        neptuneIamRoleArn: [],
+        previousModelTrainingJobId: [],
+        s3OutputEncryptionKMSKey: [],
+        sagemakerIamRoleArn: [],
+        securityGroupIds: (_) => _json(_),
+        subnets: (_) => _json(_),
+        trainModelS3Location: [],
+        trainingInstanceType: [],
+        trainingInstanceVolumeSizeInGB: [],
+        trainingTimeOutInSeconds: [],
+        volumeEncryptionKMSKey: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_StartMLModelTransformJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ml/modeltransform";
+    let body;
+    body = JSON.stringify(take(input, {
+        baseProcessingInstanceType: [],
+        baseProcessingInstanceVolumeSizeInGB: [],
+        customModelTransformParameters: (_) => _json(_),
+        dataProcessingJobId: [],
+        id: [],
+        mlModelTrainingJobId: [],
+        modelTransformOutputS3Location: [],
+        neptuneIamRoleArn: [],
+        s3OutputEncryptionKMSKey: [],
+        sagemakerIamRoleArn: [],
+        securityGroupIds: (_) => _json(_),
+        subnets: (_) => _json(_),
+        trainingJobName: [],
+        volumeEncryptionKMSKey: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const de_CancelGremlinQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CancelGremlinQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CancelGremlinQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_CancelLoaderJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CancelLoaderJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CancelLoaderJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "BulkLoadIdNotFoundException":
+        case "com.amazonaws.neptunedata#BulkLoadIdNotFoundException":
+            throw await de_BulkLoadIdNotFoundExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.neptunedata#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "LoadUrlAccessDeniedException":
+        case "com.amazonaws.neptunedata#LoadUrlAccessDeniedException":
+            throw await de_LoadUrlAccessDeniedExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_CancelMLDataProcessingJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CancelMLDataProcessingJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CancelMLDataProcessingJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_CancelMLModelTrainingJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CancelMLModelTrainingJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CancelMLModelTrainingJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_CancelMLModelTransformJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CancelMLModelTransformJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CancelMLModelTransformJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_CancelOpenCypherQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CancelOpenCypherQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: __expectBoolean,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CancelOpenCypherQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidNumericDataException":
+        case "com.amazonaws.neptunedata#InvalidNumericDataException":
+            throw await de_InvalidNumericDataExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_CreateMLEndpointCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateMLEndpointCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        creationTimeInMillis: __expectLong,
+        id: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateMLEndpointCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_DeleteMLEndpointCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteMLEndpointCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DeleteMLEndpointCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_DeletePropertygraphStatisticsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeletePropertygraphStatisticsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    map(contents, {
+        statusCode: [, output.statusCode],
+    });
+    return contents;
+};
+const de_DeletePropertygraphStatisticsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_DeleteSparqlStatisticsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteSparqlStatisticsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    map(contents, {
+        statusCode: [, output.statusCode],
+    });
+    return contents;
+};
+const de_DeleteSparqlStatisticsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ExecuteFastResetCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ExecuteFastResetCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ExecuteFastResetCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MethodNotAllowedException":
+        case "com.amazonaws.neptunedata#MethodNotAllowedException":
+            throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "ServerShutdownException":
+        case "com.amazonaws.neptunedata#ServerShutdownException":
+            throw await de_ServerShutdownExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ExecuteGremlinExplainQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ExecuteGremlinExplainQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = await collectBody(output.body, context);
+    contents.output = data;
+    return contents;
+};
+const de_ExecuteGremlinExplainQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "CancelledByUserException":
+        case "com.amazonaws.neptunedata#CancelledByUserException":
+            throw await de_CancelledByUserExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MalformedQueryException":
+        case "com.amazonaws.neptunedata#MalformedQueryException":
+            throw await de_MalformedQueryExceptionRes(parsedOutput, context);
+        case "MemoryLimitExceededException":
+        case "com.amazonaws.neptunedata#MemoryLimitExceededException":
+            throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "QueryLimitExceededException":
+        case "com.amazonaws.neptunedata#QueryLimitExceededException":
+            throw await de_QueryLimitExceededExceptionRes(parsedOutput, context);
+        case "QueryLimitException":
+        case "com.amazonaws.neptunedata#QueryLimitException":
+            throw await de_QueryLimitExceptionRes(parsedOutput, context);
+        case "QueryTooLargeException":
+        case "com.amazonaws.neptunedata#QueryTooLargeException":
+            throw await de_QueryTooLargeExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ExecuteGremlinProfileQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ExecuteGremlinProfileQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = await collectBody(output.body, context);
+    contents.output = data;
+    return contents;
+};
+const de_ExecuteGremlinProfileQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "CancelledByUserException":
+        case "com.amazonaws.neptunedata#CancelledByUserException":
+            throw await de_CancelledByUserExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MalformedQueryException":
+        case "com.amazonaws.neptunedata#MalformedQueryException":
+            throw await de_MalformedQueryExceptionRes(parsedOutput, context);
+        case "MemoryLimitExceededException":
+        case "com.amazonaws.neptunedata#MemoryLimitExceededException":
+            throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "QueryLimitExceededException":
+        case "com.amazonaws.neptunedata#QueryLimitExceededException":
+            throw await de_QueryLimitExceededExceptionRes(parsedOutput, context);
+        case "QueryLimitException":
+        case "com.amazonaws.neptunedata#QueryLimitException":
+            throw await de_QueryLimitExceptionRes(parsedOutput, context);
+        case "QueryTooLargeException":
+        case "com.amazonaws.neptunedata#QueryTooLargeException":
+            throw await de_QueryTooLargeExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ExecuteGremlinQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ExecuteGremlinQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        meta: (_) => de_Document(_, context),
+        requestId: __expectString,
+        result: (_) => de_Document(_, context),
+        status: (_) => de_GremlinQueryStatusAttributes(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ExecuteGremlinQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "CancelledByUserException":
+        case "com.amazonaws.neptunedata#CancelledByUserException":
+            throw await de_CancelledByUserExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MalformedQueryException":
+        case "com.amazonaws.neptunedata#MalformedQueryException":
+            throw await de_MalformedQueryExceptionRes(parsedOutput, context);
+        case "MemoryLimitExceededException":
+        case "com.amazonaws.neptunedata#MemoryLimitExceededException":
+            throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "QueryLimitExceededException":
+        case "com.amazonaws.neptunedata#QueryLimitExceededException":
+            throw await de_QueryLimitExceededExceptionRes(parsedOutput, context);
+        case "QueryLimitException":
+        case "com.amazonaws.neptunedata#QueryLimitException":
+            throw await de_QueryLimitExceptionRes(parsedOutput, context);
+        case "QueryTooLargeException":
+        case "com.amazonaws.neptunedata#QueryTooLargeException":
+            throw await de_QueryTooLargeExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ExecuteOpenCypherExplainQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ExecuteOpenCypherExplainQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = await collectBody(output.body, context);
+    contents.results = data;
+    return contents;
+};
+const de_ExecuteOpenCypherExplainQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "CancelledByUserException":
+        case "com.amazonaws.neptunedata#CancelledByUserException":
+            throw await de_CancelledByUserExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidNumericDataException":
+        case "com.amazonaws.neptunedata#InvalidNumericDataException":
+            throw await de_InvalidNumericDataExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MalformedQueryException":
+        case "com.amazonaws.neptunedata#MalformedQueryException":
+            throw await de_MalformedQueryExceptionRes(parsedOutput, context);
+        case "MemoryLimitExceededException":
+        case "com.amazonaws.neptunedata#MemoryLimitExceededException":
+            throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "QueryLimitExceededException":
+        case "com.amazonaws.neptunedata#QueryLimitExceededException":
+            throw await de_QueryLimitExceededExceptionRes(parsedOutput, context);
+        case "QueryLimitException":
+        case "com.amazonaws.neptunedata#QueryLimitException":
+            throw await de_QueryLimitExceptionRes(parsedOutput, context);
+        case "QueryTooLargeException":
+        case "com.amazonaws.neptunedata#QueryTooLargeException":
+            throw await de_QueryTooLargeExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ExecuteOpenCypherQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ExecuteOpenCypherQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        results: (_) => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ExecuteOpenCypherQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "CancelledByUserException":
+        case "com.amazonaws.neptunedata#CancelledByUserException":
+            throw await de_CancelledByUserExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidNumericDataException":
+        case "com.amazonaws.neptunedata#InvalidNumericDataException":
+            throw await de_InvalidNumericDataExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MalformedQueryException":
+        case "com.amazonaws.neptunedata#MalformedQueryException":
+            throw await de_MalformedQueryExceptionRes(parsedOutput, context);
+        case "MemoryLimitExceededException":
+        case "com.amazonaws.neptunedata#MemoryLimitExceededException":
+            throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "QueryLimitExceededException":
+        case "com.amazonaws.neptunedata#QueryLimitExceededException":
+            throw await de_QueryLimitExceededExceptionRes(parsedOutput, context);
+        case "QueryLimitException":
+        case "com.amazonaws.neptunedata#QueryLimitException":
+            throw await de_QueryLimitExceptionRes(parsedOutput, context);
+        case "QueryTooLargeException":
+        case "com.amazonaws.neptunedata#QueryTooLargeException":
+            throw await de_QueryTooLargeExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetEngineStatusCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetEngineStatusCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        dbEngineVersion: __expectString,
+        dfeQueryEngine: __expectString,
+        features: (_) => de_DocumentValuedMap(_, context),
+        gremlin: _json,
+        labMode: _json,
+        opencypher: _json,
+        role: __expectString,
+        rollingBackTrxCount: __expectInt32,
+        rollingBackTrxEarliestStartTime: __expectString,
+        settings: _json,
+        sparql: _json,
+        startTime: __expectString,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetEngineStatusCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.neptunedata#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetGremlinQueryStatusCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetGremlinQueryStatusCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        queryEvalStats: (_) => de_QueryEvalStats(_, context),
+        queryId: __expectString,
+        queryString: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetGremlinQueryStatusCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetLoaderJobStatusCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetLoaderJobStatusCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: (_) => de_Document(_, context),
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetLoaderJobStatusCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "BulkLoadIdNotFoundException":
+        case "com.amazonaws.neptunedata#BulkLoadIdNotFoundException":
+            throw await de_BulkLoadIdNotFoundExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.neptunedata#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "LoadUrlAccessDeniedException":
+        case "com.amazonaws.neptunedata#LoadUrlAccessDeniedException":
+            throw await de_LoadUrlAccessDeniedExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetMLDataProcessingJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetMLDataProcessingJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        id: __expectString,
+        processingJob: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetMLDataProcessingJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetMLEndpointCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetMLEndpointCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        endpoint: _json,
+        endpointConfig: _json,
+        id: __expectString,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetMLEndpointCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetMLModelTrainingJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetMLModelTrainingJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        hpoJob: _json,
+        id: __expectString,
+        mlModels: _json,
+        modelTransformJob: _json,
+        processingJob: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetMLModelTrainingJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetMLModelTransformJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetMLModelTransformJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        baseProcessingJob: _json,
+        id: __expectString,
+        models: _json,
+        remoteModelTransformJob: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetMLModelTransformJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetOpenCypherQueryStatusCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetOpenCypherQueryStatusCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        queryEvalStats: (_) => de_QueryEvalStats(_, context),
+        queryId: __expectString,
+        queryString: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetOpenCypherQueryStatusCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidNumericDataException":
+        case "com.amazonaws.neptunedata#InvalidNumericDataException":
+            throw await de_InvalidNumericDataExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetPropertygraphStatisticsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetPropertygraphStatisticsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: (_) => de_Statistics(_, context),
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetPropertygraphStatisticsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetPropertygraphStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetPropertygraphStreamCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        format: __expectString,
+        lastEventId: _json,
+        lastTrxTimestampInMillis: [, __expectLong, `lastTrxTimestamp`],
+        records: (_) => de_PropertygraphRecordsList(_, context),
+        totalRecords: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetPropertygraphStreamCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "ExpiredStreamException":
+        case "com.amazonaws.neptunedata#ExpiredStreamException":
+            throw await de_ExpiredStreamExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MemoryLimitExceededException":
+        case "com.amazonaws.neptunedata#MemoryLimitExceededException":
+            throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "StreamRecordsNotFoundException":
+        case "com.amazonaws.neptunedata#StreamRecordsNotFoundException":
+            throw await de_StreamRecordsNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.neptunedata#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetPropertygraphSummaryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetPropertygraphSummaryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: (_) => de_PropertygraphSummaryValueMap(_, context),
+    });
+    Object.assign(contents, doc);
+    map(contents, {
+        statusCode: [, output.statusCode],
+    });
+    return contents;
+};
+const de_GetPropertygraphSummaryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetRDFGraphSummaryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetRDFGraphSummaryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: (_) => de_RDFGraphSummaryValueMap(_, context),
+    });
+    Object.assign(contents, doc);
+    map(contents, {
+        statusCode: [, output.statusCode],
+    });
+    return contents;
+};
+const de_GetRDFGraphSummaryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetSparqlStatisticsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetSparqlStatisticsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: (_) => de_Statistics(_, context),
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetSparqlStatisticsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_GetSparqlStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetSparqlStreamCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        format: __expectString,
+        lastEventId: _json,
+        lastTrxTimestampInMillis: [, __expectLong, `lastTrxTimestamp`],
+        records: (_) => de_SparqlRecordsList(_, context),
+        totalRecords: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetSparqlStreamCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "ExpiredStreamException":
+        case "com.amazonaws.neptunedata#ExpiredStreamException":
+            throw await de_ExpiredStreamExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MemoryLimitExceededException":
+        case "com.amazonaws.neptunedata#MemoryLimitExceededException":
+            throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "StreamRecordsNotFoundException":
+        case "com.amazonaws.neptunedata#StreamRecordsNotFoundException":
+            throw await de_StreamRecordsNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.neptunedata#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListGremlinQueriesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListGremlinQueriesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        acceptedQueryCount: __expectInt32,
+        queries: (_) => de_GremlinQueries(_, context),
+        runningQueryCount: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListGremlinQueriesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListLoaderJobsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListLoaderJobsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListLoaderJobsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "BulkLoadIdNotFoundException":
+        case "com.amazonaws.neptunedata#BulkLoadIdNotFoundException":
+            throw await de_BulkLoadIdNotFoundExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.neptunedata#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "LoadUrlAccessDeniedException":
+        case "com.amazonaws.neptunedata#LoadUrlAccessDeniedException":
+            throw await de_LoadUrlAccessDeniedExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListMLDataProcessingJobsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListMLDataProcessingJobsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ids: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListMLDataProcessingJobsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListMLEndpointsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListMLEndpointsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ids: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListMLEndpointsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListMLModelTrainingJobsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListMLModelTrainingJobsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ids: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListMLModelTrainingJobsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListMLModelTransformJobsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListMLModelTransformJobsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ids: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListMLModelTransformJobsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListOpenCypherQueriesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListOpenCypherQueriesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        acceptedQueryCount: __expectInt32,
+        queries: (_) => de_OpenCypherQueries(_, context),
+        runningQueryCount: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListOpenCypherQueriesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.neptunedata#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "FailureByQueryException":
+        case "com.amazonaws.neptunedata#FailureByQueryException":
+            throw await de_FailureByQueryExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidNumericDataException":
+        case "com.amazonaws.neptunedata#InvalidNumericDataException":
+            throw await de_InvalidNumericDataExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "ParsingException":
+        case "com.amazonaws.neptunedata#ParsingException":
+            throw await de_ParsingExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "TimeLimitExceededException":
+        case "com.amazonaws.neptunedata#TimeLimitExceededException":
+            throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ManagePropertygraphStatisticsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ManagePropertygraphStatisticsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ManagePropertygraphStatisticsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ManageSparqlStatisticsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ManageSparqlStatisticsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ManageSparqlStatisticsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunedata#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "ReadOnlyViolationException":
+        case "com.amazonaws.neptunedata#ReadOnlyViolationException":
+            throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);
+        case "StatisticsNotAvailableException":
+        case "com.amazonaws.neptunedata#StatisticsNotAvailableException":
+            throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_StartLoaderJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_StartLoaderJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        payload: _json,
+        status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StartLoaderJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "BulkLoadIdNotFoundException":
+        case "com.amazonaws.neptunedata#BulkLoadIdNotFoundException":
+            throw await de_BulkLoadIdNotFoundExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.neptunedata#InternalFailureException":
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "LoadUrlAccessDeniedException":
+        case "com.amazonaws.neptunedata#LoadUrlAccessDeniedException":
+            throw await de_LoadUrlAccessDeniedExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "S3Exception":
+        case "com.amazonaws.neptunedata#S3Exception":
+            throw await de_S3ExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_StartMLDataProcessingJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_StartMLDataProcessingJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        creationTimeInMillis: __expectLong,
+        id: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StartMLDataProcessingJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_StartMLModelTrainingJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_StartMLModelTrainingJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        creationTimeInMillis: __expectLong,
+        id: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StartMLModelTrainingJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_StartMLModelTransformJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_StartMLModelTransformJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        creationTimeInMillis: __expectLong,
+        id: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_StartMLModelTransformJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.neptunedata#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ClientTimeoutException":
+        case "com.amazonaws.neptunedata#ClientTimeoutException":
+            throw await de_ClientTimeoutExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.neptunedata#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "IllegalArgumentException":
+        case "com.amazonaws.neptunedata#IllegalArgumentException":
+            throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.neptunedata#InvalidArgumentException":
+            throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.neptunedata#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "MLResourceNotFoundException":
+        case "com.amazonaws.neptunedata#MLResourceNotFoundException":
+            throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);
+        case "MissingParameterException":
+        case "com.amazonaws.neptunedata#MissingParameterException":
+            throw await de_MissingParameterExceptionRes(parsedOutput, context);
+        case "PreconditionsFailedException":
+        case "com.amazonaws.neptunedata#PreconditionsFailedException":
+            throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.neptunedata#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnsupportedOperationException":
+        case "com.amazonaws.neptunedata#UnsupportedOperationException":
+            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const throwDefaultError = withBaseException(__BaseException);
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new BadRequestException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_BulkLoadIdNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new BulkLoadIdNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_CancelledByUserExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new CancelledByUserException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ClientTimeoutExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ClientTimeoutException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConcurrentModificationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ConstraintViolationExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConstraintViolationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ExpiredStreamExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ExpiredStreamException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_FailureByQueryExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new FailureByQueryException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_IllegalArgumentExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new IllegalArgumentException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InternalFailureException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InvalidArgumentExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidArgumentException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InvalidNumericDataExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidNumericDataException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidParameterException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_LoadUrlAccessDeniedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new LoadUrlAccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_MalformedQueryExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MalformedQueryException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_MemoryLimitExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MemoryLimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_MethodNotAllowedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MethodNotAllowedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_MissingParameterExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MissingParameterException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_MLResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MLResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ParsingExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ParsingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_PreconditionsFailedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new PreconditionsFailedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_QueryLimitExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new QueryLimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_QueryLimitExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new QueryLimitException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_QueryTooLargeExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new QueryTooLargeException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ReadOnlyViolationExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ReadOnlyViolationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_S3ExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new S3Exception({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ServerShutdownExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ServerShutdownException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_StatisticsNotAvailableExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new StatisticsNotAvailableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_StreamRecordsNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new StreamRecordsNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_TimeLimitExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new TimeLimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new TooManyRequestsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_UnsupportedOperationExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        code: __expectString,
+        detailedMessage: __expectString,
+        requestId: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UnsupportedOperationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_DocumentValuedMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = de_Document(value, context);
+        return acc;
+    }, {});
+};
+const de_GremlinQueries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_GremlinQueryStatus(entry, context);
+    });
+    return retVal;
+};
+const de_GremlinQueryStatus = (output, context) => {
+    return take(output, {
+        queryEvalStats: (_) => de_QueryEvalStats(_, context),
+        queryId: __expectString,
+        queryString: __expectString,
+    });
+};
+const de_GremlinQueryStatusAttributes = (output, context) => {
+    return take(output, {
+        attributes: (_) => de_Document(_, context),
+        code: __expectInt32,
+        message: __expectString,
+    });
+};
+const de_OpenCypherQueries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_GremlinQueryStatus(entry, context);
+    });
+    return retVal;
+};
+const de_PropertygraphData = (output, context) => {
+    return take(output, {
+        from: __expectString,
+        id: __expectString,
+        key: __expectString,
+        to: __expectString,
+        type: __expectString,
+        value: (_) => de_Document(_, context),
+    });
+};
+const de_PropertygraphRecord = (output, context) => {
+    return take(output, {
+        commitTimestampInMillis: [, __expectLong, `commitTimestamp`],
+        data: (_) => de_PropertygraphData(_, context),
+        eventId: _json,
+        isLastOp: __expectBoolean,
+        op: __expectString,
+    });
+};
+const de_PropertygraphRecordsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_PropertygraphRecord(entry, context);
+    });
+    return retVal;
+};
+const de_PropertygraphSummaryValueMap = (output, context) => {
+    return take(output, {
+        graphSummary: _json,
+        lastStatisticsComputationTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        version: __expectString,
+    });
+};
+const de_QueryEvalStats = (output, context) => {
+    return take(output, {
+        cancelled: __expectBoolean,
+        elapsed: __expectInt32,
+        subqueries: (_) => de_Document(_, context),
+        waited: __expectInt32,
+    });
+};
+const de_RDFGraphSummaryValueMap = (output, context) => {
+    return take(output, {
+        graphSummary: _json,
+        lastStatisticsComputationTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        version: __expectString,
+    });
+};
+const de_SparqlRecord = (output, context) => {
+    return take(output, {
+        commitTimestampInMillis: [, __expectLong, `commitTimestamp`],
+        data: _json,
+        eventId: _json,
+        isLastOp: __expectBoolean,
+        op: __expectString,
+    });
+};
+const de_SparqlRecordsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_SparqlRecord(entry, context);
+    });
+    return retVal;
+};
+const de_Statistics = (output, context) => {
+    return take(output, {
+        active: __expectBoolean,
+        autoCompute: __expectBoolean,
+        date: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        note: __expectString,
+        signatureInfo: _json,
+        statisticsId: __expectString,
+    });
+};
+const de_Document = (output, context) => {
+    return output;
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+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 parseErrorBody = async (errorBody, context) => {
+    const value = await parseBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
+};
+const loadRestJsonErrorCode = (output, data) => {
+    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        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"]);
+    }
+};